lumibot 4.0.23__py3-none-any.whl → 4.1.0__py3-none-any.whl

tests/backtest/check_volume_spike.py

@@ -0,0 +1,112 @@
+"""
+Check where the volume spike happens to determine which provider is correct.
+Market opens at 9:30 AM, so we should see a massive volume spike AT 9:30 AM.
+"""
+
+import requests
+import datetime
+import pandas as pd
+from polygon import RESTClient
+from lumibot.credentials import POLYGON_API_KEY
+
+
+def check_volume_pattern(symbol, date_str):
+    """Check volume patterns around market open."""
+
+    print(f"\n{'='*100}")
+    print(f"{symbol} - Volume Pattern Analysis")
+    print(f"{'='*100}")
+
+    # Get ThetaData
+    response = requests.get('http://127.0.0.1:25510/hist/stock/ohlc', params={
+        'root': symbol,
+        'start_date': date_str,
+        'end_date': date_str,
+        'ivl': 60000,
+        'rth': 'true'
+    })
+
+    data = response.json()
+    theta_bars = []
+    for row in data['response'][:15]:  # First 15 bars
+        ms_of_day, o, h, l, c, v, count, date = row
+        hours = ms_of_day // (1000 * 60 * 60)
+        minutes = (ms_of_day % (1000 * 60 * 60)) // (1000 * 60)
+        theta_bars.append({
+            'time': f"{hours:02d}:{minutes:02d}",
+            'volume': v
+        })
+
+    # Get Polygon
+    client = RESTClient(POLYGON_API_KEY)
+    date = datetime.date(2024, 8, 1)
+    aggs = client.get_aggs(ticker=symbol, multiplier=1, timespan="minute", from_=date, to=date, limit=50000)
+
+    polygon_bars = []
+    for agg in aggs:
+        dt = datetime.datetime.fromtimestamp(agg.timestamp/1000, tz=datetime.timezone.utc)
+        dt_et = dt.astimezone(datetime.timezone(datetime.timedelta(hours=-4)))
+
+        # Only first 15 bars after 9:25
+        if dt_et.hour == 9 and dt_et.minute >= 25 and len(polygon_bars) < 15:
+            polygon_bars.append({
+                'time': dt_et.strftime("%H:%M"),
+                'volume': agg.volume
+            })
+        elif dt_et.hour > 9 and len(polygon_bars) < 15:
+            polygon_bars.append({
+                'time': dt_et.strftime("%H:%M"),
+                'volume': agg.volume
+            })
+
+    print(f"\nThetaData Bars (first 15):")
+    print(f"{'Time':<10} {'Volume':>15} {'Notes':<30}")
+    print("-" * 60)
+    max_theta_vol = max(b['volume'] for b in theta_bars)
+    for bar in theta_bars:
+        note = "← SPIKE!" if bar['volume'] == max_theta_vol else ""
+        print(f"{bar['time']:<10} {bar['volume']:>15,} {note:<30}")
+
+    print(f"\nPolygon Bars (first 15):")
+    print(f"{'Time':<10} {'Volume':>15} {'Notes':<30}")
+    print("-" * 60)
+    max_polygon_vol = max(b['volume'] for b in polygon_bars)
+    for bar in polygon_bars:
+        note = "← SPIKE!" if bar['volume'] == max_polygon_vol else ""
+        print(f"{bar['time']:<10} {bar['volume']:>15,} {note:<30}")
+
+    # Analysis
+    theta_spike_time = next(b['time'] for b in theta_bars if b['volume'] == max_theta_vol)
+    polygon_spike_time = next(b['time'] for b in polygon_bars if b['volume'] == max_polygon_vol)
+
+    print(f"\n{'='*100}")
+    print(f"ANALYSIS")
+    print(f"{'='*100}")
+    print(f"ThetaData: Volume spike at {theta_spike_time}")
+    print(f"Polygon:   Volume spike at {polygon_spike_time}")
+    print(f"\nMarket officially opens at 9:30 AM ET")
+
+    if polygon_spike_time == "09:30":
+        print(f"✓ Polygon shows spike at 9:30 AM (CORRECT - matches market open)")
+    else:
+        print(f"✗ Polygon shows spike at {polygon_spike_time} (WRONG - doesn't match market open)")
+
+    if theta_spike_time == "09:30":
+        print(f"✓ ThetaData shows spike at 9:30 AM (CORRECT - matches market open)")
+    elif theta_spike_time == "09:31":
+        print(f"✗ ThetaData shows spike at 9:31 AM (WRONG - should be at 9:30)")
+        print(f"  → This suggests ThetaData timestamps are OFF BY +1 MINUTE")
+    else:
+        print(f"✗ ThetaData shows spike at {theta_spike_time} (UNEXPECTED)")
+
+
+def main():
+    symbols = ["AMZN", "AAPL", "SPY"]
+    date_str = "20240801"
+
+    for symbol in symbols:
+        check_volume_pattern(symbol, date_str)
+
+
+if __name__ == "__main__":
+    main()

tests/backtest/comprehensive_comparison.py

@@ -0,0 +1,166 @@
+"""
+Comprehensive comparison test between ThetaData and Polygon across:
+- Multiple stocks (AMZN, AAPL, SPY, TSLA, PLTR)
+- Multiple times of day (9:30, 10:00, 12:00, 15:00, 15:30)
+- Check for systematic patterns vs random differences
+"""
+
+import datetime
+import os
+import pandas as pd
+from lumibot.backtesting import ThetaDataBacktesting, PolygonDataBacktesting
+from lumibot.entities import Asset
+from lumibot.credentials import POLYGON_API_KEY
+
+
+def get_bar_at_time(data_source_class, symbol, date, hour, minute):
+    """Get a specific bar from a data source."""
+    start = datetime.datetime(date.year, date.month, date.day, 9, 0)
+    end = datetime.datetime(date.year, date.month, date.day, 16, 0)
+
+    if data_source_class == ThetaDataBacktesting:
+        ds = ThetaDataBacktesting(
+            datetime_start=start,
+            datetime_end=end,
+            username=os.environ.get("THETADATA_USERNAME"),
+            password=os.environ.get("THETADATA_PASSWORD"),
+        )
+    else:
+        ds = PolygonDataBacktesting(
+            datetime_start=start,
+            datetime_end=end,
+            api_key=POLYGON_API_KEY,
+        )
+
+    asset = Asset(symbol, asset_type="stock")
+
+    # Get all bars for the day
+    bars = ds.get_historical_prices_between_dates(asset, "minute", start_date=start, end_date=end)
+
+    if bars and not bars.df.empty:
+        # Find the bar at our target time
+        df = bars.df
+
+        # Try to find bars matching our target time
+        for idx in df.index:
+            if idx.hour == hour and idx.minute == minute:
+                bar = df.loc[idx]
+                return {
+                    "symbol": symbol,
+                    "datetime": idx,
+                    "open": float(bar["open"]),
+                    "high": float(bar["high"]),
+                    "low": float(bar["low"]),
+                    "close": float(bar["close"]),
+                    "volume": float(bar["volume"]),
+                }
+
+    return None
+
+
+def compare_providers():
+    """Compare ThetaData vs Polygon across multiple stocks and times."""
+
+    test_date = datetime.date(2024, 8, 1)
+    symbols = ["AMZN", "AAPL", "SPY", "TSLA", "PLTR"]
+    times = [
+        (9, 30, "Market Open"),
+        (10, 0, "Early Morning"),
+        (12, 0, "Midday"),
+        (14, 0, "Afternoon"),
+        (15, 30, "Near Close"),
+    ]
+
+    results = []
+
+    print(f"\nComprehensive ThetaData vs Polygon Comparison")
+    print(f"Date: {test_date}")
+    print(f"=" * 120)
+
+    for symbol in symbols:
+        print(f"\n{symbol}:")
+        print("-" * 120)
+
+        for hour, minute, label in times:
+            print(f"\n  {label} ({hour}:{minute:02d} ET):")
+
+            try:
+                theta_bar = get_bar_at_time(ThetaDataBacktesting, symbol, test_date, hour, minute)
+                polygon_bar = get_bar_at_time(PolygonDataBacktesting, symbol, test_date, hour, minute)
+
+                if theta_bar and polygon_bar:
+                    # Calculate differences
+                    open_diff = theta_bar["open"] - polygon_bar["open"]
+                    close_diff = theta_bar["close"] - polygon_bar["close"]
+                    volume_diff = theta_bar["volume"] - polygon_bar["volume"]
+                    volume_pct = (volume_diff / polygon_bar["volume"] * 100) if polygon_bar["volume"] > 0 else 0
+
+                    print(f"    ThetaData : O=${theta_bar['open']:.2f} H=${theta_bar['high']:.2f} L=${theta_bar['low']:.2f} C=${theta_bar['close']:.2f} V={theta_bar['volume']:,.0f}")
+                    print(f"    Polygon   : O=${polygon_bar['open']:.2f} H=${polygon_bar['high']:.2f} L=${polygon_bar['low']:.2f} C=${polygon_bar['close']:.2f} V={polygon_bar['volume']:,.0f}")
+                    print(f"    Difference: O=${open_diff:+.3f} C=${close_diff:+.3f} V={volume_diff:+,.0f} ({volume_pct:+.1f}%)")
+
+                    results.append({
+                        "symbol": symbol,
+                        "time": f"{hour}:{minute:02d}",
+                        "label": label,
+                        "theta_open": theta_bar["open"],
+                        "polygon_open": polygon_bar["open"],
+                        "open_diff": open_diff,
+                        "theta_close": theta_bar["close"],
+                        "polygon_close": polygon_bar["close"],
+                        "close_diff": close_diff,
+                        "theta_volume": theta_bar["volume"],
+                        "polygon_volume": polygon_bar["volume"],
+                        "volume_diff": volume_diff,
+                        "volume_pct_diff": volume_pct,
+                    })
+                else:
+                    print(f"    ❌ Missing data (Theta: {theta_bar is not None}, Polygon: {polygon_bar is not None})")
+
+            except Exception as e:
+                print(f"    ❌ Error: {e}")
+
+    # Create summary statistics
+    if results:
+        df = pd.DataFrame(results)
+
+        print(f"\n{'=' * 120}")
+        print(f"SUMMARY STATISTICS")
+        print(f"{'=' * 120}")
+
+        print(f"\nPrice Differences (Open):")
+        print(f"  Mean: ${df['open_diff'].mean():.4f}")
+        print(f"  Std:  ${df['open_diff'].std():.4f}")
+        print(f"  Min:  ${df['open_diff'].min():.4f}")
+        print(f"  Max:  ${df['open_diff'].max():.4f}")
+        print(f"  Abs Mean: ${df['open_diff'].abs().mean():.4f}")
+
+        print(f"\nPrice Differences (Close):")
+        print(f"  Mean: ${df['close_diff'].mean():.4f}")
+        print(f"  Std:  ${df['close_diff'].std():.4f}")
+        print(f"  Min:  ${df['close_diff'].min():.4f}")
+        print(f"  Max:  ${df['close_diff'].max():.4f}")
+        print(f"  Abs Mean: ${df['close_diff'].abs().mean():.4f}")
+
+        print(f"\nVolume Differences:")
+        print(f"  Mean: {df['volume_diff'].mean():,.0f} ({df['volume_pct_diff'].mean():+.2f}%)")
+        print(f"  Std:  {df['volume_diff'].std():,.0f}")
+        print(f"  Min:  {df['volume_diff'].min():,.0f} ({df['volume_pct_diff'].min():+.2f}%)")
+        print(f"  Max:  {df['volume_diff'].max():,.0f} ({df['volume_pct_diff'].max():+.2f}%)")
+
+        # Check if ThetaData consistently has higher volume
+        higher_volume_count = (df['volume_diff'] > 0).sum()
+        total_count = len(df)
+        print(f"\nThetaData has HIGHER volume in {higher_volume_count}/{total_count} cases ({higher_volume_count/total_count*100:.1f}%)")
+
+        # Save to CSV
+        df.to_csv("thetadata_vs_polygon_comparison.csv", index=False)
+        print(f"\n✓ Results saved to thetadata_vs_polygon_comparison.csv")
+
+        return df
+
+    return None
+
+
+if __name__ == "__main__":
+    compare_providers()

tests/backtest/debug_comparison.py

@@ -0,0 +1,91 @@
+"""
+Deep dive comparison: ThetaData vs Polygon
+Logs every detail to understand divergence
+"""
+import os
+import sys
+import logging
+from datetime import datetime
+from pathlib import Path
+
+# Enable detailed logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('/tmp/thetadata_debug.log'),
+        logging.StreamHandler()
+    ]
+)
+
+# Set environment
+os.environ['BACKTESTING_START'] = '2025-09-01'
+os.environ['BACKTESTING_END'] = '2025-09-05'
+os.environ['BACKTESTING_QUIET_LOGS'] = 'False'
+os.environ['BACKTESTING_SHOW_PROGRESS_BAR'] = 'True'
+
+sys.path.insert(0, '/Users/robertgrzesik/Documents/Development/lumivest_bot_server/strategies/lumibot')
+
+from lumibot.strategies import Strategy
+from lumibot.entities import Asset
+from lumibot.backtesting import ThetaDataBacktesting, PolygonDataBacktesting
+from dotenv import load_dotenv
+
+load_dotenv('/Users/robertgrzesik/Documents/Development/Strategy Library/Demos/.env.test')
+
+# Import the strategy
+exec(open('/Users/robertgrzesik/Documents/Development/Strategy Library/Demos/PLTR Weekly Call Roller.py').read())
+
+print("=" * 100)
+print("DETAILED THETADATA BACKTEST")
+print("=" * 100)
+
+os.environ['BACKTESTING_DATA_SOURCE'] = 'ThetaData'
+theta_results = PLTRWeeklyCallRoller.backtest(
+    ThetaDataBacktesting,
+    backtesting_start=datetime(2025, 9, 1),
+    backtesting_end=datetime(2025, 9, 5),
+    benchmark_asset=Asset("SPY", Asset.AssetType.STOCK),
+    quote_asset=Asset("USD", Asset.AssetType.FOREX),
+)
+
+print("\n" + "=" * 100)
+print("DETAILED POLYGON BACKTEST")
+print("=" * 100)
+
+os.environ['BACKTESTING_DATA_SOURCE'] = 'Polygon'
+polygon_results = PLTRWeeklyCallRoller.backtest(
+    PolygonDataBacktesting,
+    backtesting_start=datetime(2025, 9, 1),
+    backtesting_end=datetime(2025, 9, 5),
+    benchmark_asset=Asset("SPY", Asset.AssetType.STOCK),
+    quote_asset=Asset("USD", Asset.AssetType.FOREX),
+)
+
+print("\n" + "=" * 100)
+print("COMPARISON ANALYSIS")
+print("=" * 100)
+
+# Portfolio values
+theta_final = theta_results['portfolio_value'][-1]
+polygon_final = polygon_results['portfolio_value'][-1]
+
+print(f"\nFinal Portfolio Values:")
+print(f"  ThetaData: ${theta_final:,.2f}")
+print(f"  Polygon:   ${polygon_final:,.2f}")
+print(f"  Difference: ${abs(theta_final - polygon_final):,.2f}")
+
+# Returns
+theta_return = (theta_final - 100000) / 100000 * 100
+polygon_return = (polygon_final - 100000) / 100000 * 100
+print(f"\nReturns:")
+print(f"  ThetaData: {theta_return:.2f}%")
+print(f"  Polygon:   {polygon_return:.2f}%")
+
+# Analyze trades from logs
+print(f"\nLog file created at: /tmp/thetadata_debug.log")
+print("Search log for:")
+print("  - 'Submitting order' to see trade submissions")
+print("  - 'Fill price' to see execution prices")
+print("  - 'bid' and 'ask' to see quote data")
+print("  - 'get_last_price' to see price lookups")

tests/backtest/diagnose_price_difference.py

@@ -0,0 +1,97 @@
+"""
+Diagnostic script to examine raw bar data from ThetaData and Polygon
+to understand why prices differ.
+"""
+
+import datetime
+import os
+from lumibot.backtesting import ThetaDataBacktesting, PolygonDataBacktesting
+from lumibot.entities import Asset
+from lumibot.credentials import POLYGON_API_KEY
+
+
+def examine_data_source(data_source_class, name):
+    """Examine raw data from a data source."""
+    print(f"\n{'='*80}")
+    print(f"{name} Data Source")
+    print(f"{'='*80}")
+
+    start = datetime.datetime(2024, 8, 1, 9, 30)
+    end = datetime.datetime(2024, 8, 1, 10, 0)
+
+    if data_source_class == ThetaDataBacktesting:
+        data_source = ThetaDataBacktesting(
+            datetime_start=start,
+            datetime_end=end,
+            username=os.environ.get("THETADATA_USERNAME"),
+            password=os.environ.get("THETADATA_PASSWORD"),
+        )
+    else:
+        data_source = PolygonDataBacktesting(
+            datetime_start=start,
+            datetime_end=end,
+            api_key=POLYGON_API_KEY,
+        )
+
+    # Set datetime to 9:30 AM
+    data_source.datetime = datetime.datetime(2024, 8, 1, 9, 30, tzinfo=datetime.timezone(datetime.timedelta(hours=-4)))
+
+    asset = Asset("AMZN", asset_type="stock")
+
+    # Get historical bars
+    bars = data_source.get_historical_prices(asset, 5, "minute")
+
+    if bars:
+        df = bars.df
+        print(f"\nFirst 5 minute bars:")
+        print(df.head(10))
+        print(f"\nColumns: {df.columns.tolist()}")
+        print(f"\nFirst bar details:")
+        first_bar = df.iloc[0]
+        for col in df.columns:
+            print(f"  {col}: {first_bar[col]}")
+    else:
+        print("No bars returned")
+
+    # Get last price
+    price = data_source.get_last_price(asset)
+    print(f"\nget_last_price(): ${price}")
+
+    # Get the Data object and check what bar it's using
+    tuple_to_find = data_source.find_asset_in_data_store(asset, None)
+    if tuple_to_find in data_source._data_store:
+        data = data_source._data_store[tuple_to_find]
+        dt = data_source.get_datetime()
+        iter_count = data.get_iter_count(dt)
+        print(f"\niter_count: {iter_count}")
+        print(f"Bar datetime: {data.datalines['datetime'].dataline[iter_count]}")
+        print(f"Bar open: {data.datalines['open'].dataline[iter_count]}")
+        print(f"Bar close: {data.datalines['close'].dataline[iter_count]}")
+        print(f"Current dt: {dt}")
+        print(f"dt > bar_datetime: {dt > data.datalines['datetime'].dataline[iter_count]}")
+
+    # Get quote
+    quote = data_source.get_quote(asset)
+    print(f"\nget_quote():")
+    print(f"  price: {quote.price}")
+    print(f"  bid: {quote.bid}")
+    print(f"  ask: {quote.ask}")
+    print(f"  volume: {quote.volume}")
+    print(f"  timestamp: {quote.timestamp}")
+    if hasattr(quote, 'raw_data') and quote.raw_data:
+        print(f"  raw_data: {quote.raw_data}")
+
+
+if __name__ == "__main__":
+    examine_data_source(ThetaDataBacktesting, "THETADATA")
+    examine_data_source(PolygonDataBacktesting, "POLYGON")
+
+    print(f"\n{'='*80}")
+    print("ANALYSIS")
+    print(f"{'='*80}")
+    print("If the 'open' prices differ in the first bar, that's the root cause.")
+    print("We need to investigate WHY the open prices differ:")
+    print("  1. Are they pulling from different exchanges?")
+    print("  2. Are they using different data types (trade vs NBBO)?")
+    print("  3. Is there a timestamp alignment issue?")
+    print("  4. Is one source incorrect?")

tests/backtest/direct_api_comparison.py

@@ -0,0 +1,203 @@
+"""
+Direct API comparison between ThetaData and Polygon.
+Bypasses Lumibot classes to isolate any framework issues.
+"""
+
+import os
+import datetime
+import pandas as pd
+import requests
+from polygon import RESTClient
+from lumibot.credentials import POLYGON_API_KEY
+
+
+def get_thetadata_bars(symbol, date_str):
+    """Get minute bars from ThetaData API directly."""
+    url = "http://127.0.0.1:25510/hist/stock/ohlc"
+    params = {
+        "root": symbol,
+        "start_date": date_str,
+        "end_date": date_str,
+        "ivl": 60000,  # 1 minute
+        "rth": "true"
+    }
+
+    response = requests.get(url, params=params)
+    data = response.json()
+
+    if data and "response" in data:
+        # Convert to DataFrame
+        df = pd.DataFrame(data["response"], columns=data["header"]["format"])
+
+        # Convert to datetime - ThetaData returns ms_of_day in Eastern Time!
+        df["datetime"] = pd.to_datetime(df["date"].astype(str), format="%Y%m%d") + pd.to_timedelta(df["ms_of_day"], unit="ms")
+        df = df.set_index("datetime")
+        # Localize to Eastern Time (not UTC!)
+        df.index = df.index.tz_localize("America/New_York")
+        df = df[["open", "high", "low", "close", "volume"]]
+
+        return df
+
+    return None
+
+
+def get_polygon_bars(symbol, date):
+    """Get minute bars from Polygon API directly."""
+    client = RESTClient(POLYGON_API_KEY)
+
+    aggs = client.get_aggs(
+        ticker=symbol,
+        multiplier=1,
+        timespan="minute",
+        from_=date,
+        to=date,
+        limit=50000
+    )
+
+    bars = []
+    for agg in aggs:
+        dt = datetime.datetime.fromtimestamp(agg.timestamp/1000, tz=datetime.timezone.utc)
+        bars.append({
+            "datetime": dt,
+            "open": agg.open,
+            "high": agg.high,
+            "low": agg.low,
+            "close": agg.close,
+            "volume": agg.volume,
+        })
+
+    if bars:
+        df = pd.DataFrame(bars)
+        df = df.set_index("datetime")
+        return df
+
+    return None
+
+
+def compare_bar(theta_bar, polygon_bar, symbol, time_str):
+    """Compare a single bar from both sources."""
+    open_diff = theta_bar["open"] - polygon_bar["open"]
+    high_diff = theta_bar["high"] - polygon_bar["high"]
+    low_diff = theta_bar["low"] - polygon_bar["low"]
+    close_diff = theta_bar["close"] - polygon_bar["close"]
+    volume_diff = theta_bar["volume"] - polygon_bar["volume"]
+    volume_pct = (volume_diff / polygon_bar["volume"] * 100) if polygon_bar["volume"] > 0 else 0
+
+    print(f"\n  {time_str}:")
+    print(f"    ThetaData : O=${theta_bar['open']:.3f} H=${theta_bar['high']:.3f} L=${theta_bar['low']:.3f} C=${theta_bar['close']:.3f} V={theta_bar['volume']:,.0f}")
+    print(f"    Polygon   : O=${polygon_bar['open']:.3f} H=${polygon_bar['high']:.3f} L=${polygon_bar['low']:.3f} C=${polygon_bar['close']:.3f} V={polygon_bar['volume']:,.0f}")
+    print(f"    Difference: O=${open_diff:+.3f} H=${high_diff:+.3f} L=${low_diff:+.3f} C=${close_diff:+.3f} V={volume_diff:+,.0f} ({volume_pct:+.1f}%)")
+
+    return {
+        "symbol": symbol,
+        "time": time_str,
+        "theta_open": theta_bar["open"],
+        "polygon_open": polygon_bar["open"],
+        "open_diff": open_diff,
+        "theta_close": theta_bar["close"],
+        "polygon_close": polygon_bar["close"],
+        "close_diff": close_diff,
+        "theta_volume": theta_bar["volume"],
+        "polygon_volume": polygon_bar["volume"],
+        "volume_diff": volume_diff,
+        "volume_pct_diff": volume_pct,
+    }
+
+
+def main():
+    date = datetime.date(2024, 8, 1)
+    date_str = "20240801"
+    symbols = ["AMZN", "AAPL", "SPY", "TSLA", "PLTR"]
+
+    # Times to check (in UTC, not ET!)
+    times_to_check = [
+        ("09:30", "Market Open"),
+        ("10:00", "Early Morning"),
+        ("12:00", "Midday"),
+        ("14:00", "Afternoon"),
+        ("15:30", "Near Close"),
+    ]
+
+    results = []
+
+    print(f"\n{'='*120}")
+    print(f"Direct API Comparison: ThetaData vs Polygon")
+    print(f"Date: {date}")
+    print(f"{'='*120}")
+
+    for symbol in symbols:
+        print(f"\n{symbol}:")
+        print("-" * 120)
+
+        # Get all bars for the day from both sources
+        theta_df = get_thetadata_bars(symbol, date_str)
+        polygon_df = get_polygon_bars(symbol, date)
+
+        if theta_df is None:
+            print(f"  ❌ No ThetaData bars")
+            continue
+
+        if polygon_df is None:
+            print(f"  ❌ No Polygon bars")
+            continue
+
+        # ThetaData is already in ET, Polygon needs conversion from UTC to ET
+        polygon_df.index = polygon_df.index.tz_convert("America/New_York")
+
+        # Compare specific times
+        for time_str, label in times_to_check:
+            hour, minute = map(int, time_str.split(":"))
+
+            # Find matching bars
+            theta_matches = theta_df[(theta_df.index.hour == hour) & (theta_df.index.minute == minute)]
+            polygon_matches = polygon_df[(polygon_df.index.hour == hour) & (polygon_df.index.minute == minute)]
+
+            if not theta_matches.empty and not polygon_matches.empty:
+                theta_bar = theta_matches.iloc[0]
+                polygon_bar = polygon_matches.iloc[0]
+
+                result = compare_bar(theta_bar, polygon_bar, symbol, f"{label} ({time_str})")
+                results.append(result)
+            else:
+                print(f"\n  {label} ({time_str}): ❌ Missing bars (Theta: {not theta_matches.empty}, Polygon: {not polygon_matches.empty})")
+
+    # Summary statistics
+    if results:
+        df = pd.DataFrame(results)
+
+        print(f"\n{'='*120}")
+        print(f"SUMMARY STATISTICS ({len(results)} comparisons)")
+        print(f"{'='*120}")
+
+        print(f"\nPrice Differences (Open):")
+        print(f"  Mean:     ${df['open_diff'].mean():.4f}")
+        print(f"  Std:      ${df['open_diff'].std():.4f}")
+        print(f"  Min:      ${df['open_diff'].min():.4f}")
+        print(f"  Max:      ${df['open_diff'].max():.4f}")
+        print(f"  Abs Mean: ${df['open_diff'].abs().mean():.4f}")
+
+        print(f"\nPrice Differences (Close):")
+        print(f"  Mean:     ${df['close_diff'].mean():.4f}")
+        print(f"  Std:      ${df['close_diff'].std():.4f}")
+        print(f"  Min:      ${df['close_diff'].min():.4f}")
+        print(f"  Max:      ${df['close_diff'].max():.4f}")
+        print(f"  Abs Mean: ${df['close_diff'].abs().mean():.4f}")
+
+        print(f"\nVolume Differences:")
+        print(f"  Mean:     {df['volume_diff'].mean():,.0f} ({df['volume_pct_diff'].mean():+.2f}%)")
+        print(f"  Std:      {df['volume_diff'].std():,.0f}")
+        print(f"  Min:      {df['volume_diff'].min():,.0f} ({df['volume_pct_diff'].min():+.2f}%)")
+        print(f"  Max:      {df['volume_diff'].max():,.0f} ({df['volume_pct_diff'].max():+.2f}%)")
+
+        # Check patterns
+        higher_volume_count = (df['volume_diff'] > 0).sum()
+        total_count = len(df)
+        print(f"\nThetaData has HIGHER volume in {higher_volume_count}/{total_count} cases ({higher_volume_count/total_count*100:.1f}%)")
+
+        # Save results
+        df.to_csv("direct_api_comparison.csv", index=False)
+        print(f"\n✓ Results saved to direct_api_comparison.csv")
+
+
+if __name__ == "__main__":
+    main()