lumibot 4.2.5__py3-none-any.whl → 4.2.7__py3-none-any.whl

lumibot/backtesting/databento_backtesting_pandas.py

@@ -410,6 +410,7 @@ class DataBentoDataBacktestingPandas(PandasData):
             # OPTIMIZATION: Check cache first
             self._check_and_clear_cache()
             current_dt = self.get_datetime()
+            current_dt_aware = to_datetime_aware(current_dt)
 
             # Try to get data from our cached pandas_data first
             search_asset = asset
@@ -435,8 +436,6 @@ class DataBentoDataBacktestingPandas(PandasData):
 
                 if not df.empty and 'close' in df.columns:
                         # Ensure current_dt is timezone-aware for comparison
-                        current_dt_aware = to_datetime_aware(current_dt)
-
                         # Step back one bar so only fully closed bars are visible
                         bar_delta = timedelta(minutes=1)
                         if asset_data.timestep == "hour":
@@ -454,19 +453,45 @@ class DataBentoDataBacktestingPandas(PandasData):
                             filtered_df = df[df.index <= current_dt_aware]
 
                         if not filtered_df.empty:
-                            last_price = filtered_df['close'].iloc[-1]
-                            if not pd.isna(last_price):
-                                price = float(last_price)
+                            valid_closes = filtered_df['close'].dropna()
+                            if not valid_closes.empty:
+                                price = float(valid_closes.iloc[-1])
                                 # OPTIMIZATION: Cache the result
                                 self._last_price_cache[cache_key] = price
                                 return price
             
-            # If no cached data, try to get recent data
+            # If no cached data, try to load it for the backtest window
+            try:
+                fetched_bars = self.get_historical_prices(
+                    asset_separated,
+                    length=1,
+                    quote=quote_asset,
+                    timestep="minute",
+                )
+                if fetched_bars is not None:
+                    asset_data = self.pandas_data.get(search_asset)
+                    if asset_data is not None:
+                        df = asset_data.df
+                        if not df.empty and 'close' in df.columns:
+                            valid_closes = df[df.index <= current_dt_aware]['close'].dropna()
+                            if not valid_closes.empty:
+                                price = float(valid_closes.iloc[-1])
+                                self._last_price_cache[cache_key] = price
+                                return price
+            except Exception as exc:
+                logger.debug(
+                    "Attempted to hydrate Databento cache for %s but hit error: %s",
+                    asset.symbol,
+                    exc,
+                )
+
+            # If still no data, fall back to direct fetch (live-style)
             logger.warning(f"No cached data for {asset.symbol}, attempting direct fetch")
             return databento_helper.get_last_price_from_databento(
                 api_key=self._api_key,
                 asset=asset_separated,
-                venue=exchange
+                venue=exchange,
+                reference_date=current_dt_aware
             )
             
         except DataBentoAuthenticationError as e:

lumibot/backtesting/thetadata_backtesting_pandas.py

@@ -771,7 +771,7 @@ class ThetaDataBacktestingPandas(PandasData):
                 quote_columns = ['bid', 'ask', 'bid_size', 'ask_size', 'bid_condition', 'ask_condition', 'bid_exchange', 'ask_exchange']
                 existing_quote_cols = [col for col in quote_columns if col in df.columns]
                 if existing_quote_cols:
-                    df[existing_quote_cols] = df[existing_quote_cols].fillna(method='ffill')
+                    df[existing_quote_cols] = df[existing_quote_cols].ffill()
 
                     # Log how much forward filling occurred
                     if 'bid' in df.columns and 'ask' in df.columns:

lumibot/components/options_helper.py

@@ -1,5 +1,7 @@
 from dataclasses import dataclass
 from datetime import date, datetime, timedelta
+from decimal import Decimal
+import math
 from typing import Any, Dict, List, Optional, Tuple, Union
 import warnings
 
@@ -23,6 +25,7 @@ class OptionMarketEvaluation:
     sell_price: Optional[float]
     used_last_price_fallback: bool
     max_spread_pct: Optional[float]
+    data_quality_flags: List[str]
 
 
 class OptionsHelper:
@@ -58,6 +61,54 @@ class OptionsHelper:
         self._liquidity_deprecation_warned = False
         self.strategy.log_message("OptionsHelper initialized.", color="blue")
 
+    @staticmethod
+    def _coerce_price(value: Any, field_name: str, flags: List[str], notes: List[str]) -> Optional[float]:
+        """Normalize quote values and record data quality issues."""
+        raw_value = value
+
+        if value is None:
+            flags.append(f"{field_name}_missing")
+            return None
+
+        try:
+            if isinstance(value, Decimal):
+                value = float(value)
+            else:
+                value = float(value)  # type: ignore[arg-type]
+        except (TypeError, ValueError):
+            flags.append(f"{field_name}_non_numeric")
+            notes.append(f"{field_name} value {raw_value!r} is non-numeric; dropping.")
+            return None
+
+        if math.isnan(value) or math.isinf(value):
+            flags.append(f"{field_name}_non_finite")
+            notes.append(f"{field_name} value {value!r} is not finite; dropping.")
+            return None
+
+        if value <= 0:
+            flags.append(f"{field_name}_non_positive")
+            notes.append(f"{field_name} value {value!r} is non-positive; dropping.")
+            return None
+
+        return value
+
+    @staticmethod
+    def has_actionable_price(evaluation: Optional["OptionMarketEvaluation"]) -> bool:
+        """Return True when the evaluation contains a usable buy price."""
+        if evaluation is None:
+            return False
+
+        price = evaluation.buy_price
+        if price is None:
+            return False
+
+        try:
+            price = float(price)
+        except (TypeError, ValueError):
+            return False
+
+        return math.isfinite(price) and price > 0 and not evaluation.spread_too_wide
+
     # ============================================================
     # Basic Utility Functions
     # ============================================================
@@ -467,6 +518,9 @@ class OptionsHelper:
         buy_price: Optional[float] = None
         sell_price: Optional[float] = None
 
+        data_quality_flags: List[str] = []
+        sanitization_notes: List[str] = []
+
         # Attempt to get quotes first
         quote = None
         try:
@@ -478,24 +532,20 @@ class OptionsHelper:
             )
 
         if quote and quote.bid is not None and quote.ask is not None:
-            try:
-                bid = float(quote.bid)
-                ask = float(quote.ask)
-            except (TypeError, ValueError):
-                bid = quote.bid
-                ask = quote.ask
+            bid = self._coerce_price(quote.bid, "bid", data_quality_flags, sanitization_notes)
+            ask = self._coerce_price(quote.ask, "ask", data_quality_flags, sanitization_notes)
             has_bid_ask = bid is not None and ask is not None
 
         if has_bid_ask and bid is not None and ask is not None:
             buy_price = ask
             sell_price = bid
-            mid = (ask + bid) / 2 if (ask is not None and bid is not None) else None
-            if mid and mid > 0:
+            mid = (ask + bid) / 2
+            if not math.isfinite(mid) or mid <= 0:
+                spread_pct = None
+            else:
                 spread_pct = (ask - bid) / mid
                 if max_spread_pct is not None:
                     spread_too_wide = spread_pct > max_spread_pct
-            else:
-                spread_pct = None
         else:
             missing_bid_ask = True
 
@@ -510,6 +560,10 @@ class OptionsHelper:
 
         if last_price is None:
             missing_last_price = True
+        else:
+            last_price = self._coerce_price(last_price, "last_price", data_quality_flags, sanitization_notes)
+            if last_price is None:
+                missing_last_price = True
 
         if not has_bid_ask and allow_fallback and last_price is not None:
             buy_price = last_price
@@ -519,6 +573,14 @@ class OptionsHelper:
                 f"Using last-price fallback for {option_asset} due to missing bid/ask quotes.",
                 color="yellow",
             )
+        elif not has_bid_ask and allow_fallback and last_price is None:
+            data_quality_flags.append("last_price_unusable")
+
+        if buy_price is not None and (not math.isfinite(buy_price) or buy_price <= 0):
+            sanitization_notes.append(f"buy_price {buy_price!r} is not actionable; clearing.")
+            data_quality_flags.append("buy_price_non_finite")
+            buy_price = None
+            sell_price = None
 
         # Compose log message
         spread_str = f"{spread_pct:.2%}" if spread_pct is not None else "None"
@@ -526,6 +588,12 @@ class OptionsHelper:
         log_color = "red" if spread_too_wide else (
             "yellow" if (missing_bid_ask or missing_last_price or used_last_price_fallback) else "blue"
         )
+        if sanitization_notes:
+            note_summary = "; ".join(sanitization_notes)
+            self.strategy.log_message(
+                f"Option data sanitization for {option_asset}: {note_summary}",
+                color="yellow",
+            )
         self.strategy.log_message(
             (
                 f"Option market evaluation for {option_asset}: "
@@ -533,7 +601,8 @@ class OptionsHelper:
                 f"max_spread={max_spread_str}, missing_bid_ask={missing_bid_ask}, "
                 f"missing_last_price={missing_last_price}, spread_too_wide={spread_too_wide}, "
                 f"used_last_price_fallback={used_last_price_fallback}, "
-                f"buy_price={buy_price}, sell_price={sell_price}"
+                f"buy_price={buy_price}, sell_price={sell_price}, "
+                f"data_quality_flags={data_quality_flags}"
             ),
             color=log_color,
         )
@@ -551,6 +620,7 @@ class OptionsHelper:
             sell_price=sell_price,
             used_last_price_fallback=used_last_price_fallback,
             max_spread_pct=max_spread_pct,
+            data_quality_flags=data_quality_flags,
         )
 
     def check_option_liquidity(self, option_asset: Asset, max_spread_pct: float) -> bool:
@@ -721,18 +791,11 @@ class OptionsHelper:
                     self.strategy.log_message(f"Cannot validate data without underlying symbol, returning {exp_date}", color="yellow")
                     return exp_date
 
-        # No future expirations with valid data; log and check last available
-        if expiration_dates:
-            # Check the last available expiry for data
-            for exp_str, exp_date in reversed(expiration_dates):
-                strikes = specific_chain.get(exp_str)
-                if strikes and len(strikes) > 0:
-                    self.strategy.log_message(
-                        f"No valid expirations on or after {dt}; using latest available {exp_date} for {call_or_put_caps}.",
-                        color="yellow",
-                    )
-                    return exp_date
-
+        # No future expirations with tradeable data; let the caller skip entries gracefully.
+        self.strategy.log_message(
+            f"No valid expirations on or after {dt} with tradeable data for {call_or_put_caps}; skipping.",
+            color="yellow",
+        )
         return None
 
     # ============================================================

lumibot/strategies/_strategy.py

@@ -126,14 +126,20 @@ class Vars:
 class _Strategy:
     @staticmethod
     def _normalize_backtest_datetime(value):
-        """Convert backtest boundary datetimes to the LumiBot default timezone."""
+        """Ensure backtest boundary datetimes are timezone-aware.
+
+        Naive datetimes are localized to the LumiBot default timezone; timezone-aware
+        inputs are returned unchanged so their original offsets are preserved.
+        """
         if value is None:
             return None
-        aware = to_datetime_aware(value)
-        tzinfo = getattr(aware, "tzinfo", None)
-        if tzinfo is not None and tzinfo != LUMIBOT_DEFAULT_PYTZ:
-            return aware.astimezone(LUMIBOT_DEFAULT_PYTZ)
-        return aware
+        if isinstance(value, datetime.datetime):
+            tzinfo = value.tzinfo
+            if tzinfo is None or tzinfo.utcoffset(value) is None:
+                return to_datetime_aware(value)
+            if not hasattr(tzinfo, "zone"):
+                return value.astimezone(LUMIBOT_DEFAULT_PYTZ)
+        return value
 
     @property
     def is_backtesting(self) -> bool:

lumibot/tools/ccxt_data_store.py

@@ -445,7 +445,7 @@ class CcxtCacheDB:
         if freq == "1d":
             dt_range = pd.date_range(start=df.index.min(), end=df.index.max(), freq="D")
         else:
-            dt_range = pd.date_range(start=df.index.min(), end=df.index.max(), freq="T")
+            dt_range = pd.date_range(start=df.index.min(), end=df.index.max(), freq="min")
 
         df_complete = df.reindex(dt_range).ffill()
         df_complete['missing'] = np.where(df_complete.index.isin(df.index), 0, 1)

lumibot/tools/databento_helper.py

@@ -947,6 +947,7 @@ def get_last_price_from_databento(
     api_key: str,
     asset: Asset,
     venue: Optional[str] = None,
+    reference_date: Optional[datetime] = None,
     **kwargs
 ) -> Optional[Union[float, Decimal]]:
     """
@@ -978,12 +979,14 @@ def get_last_price_from_databento(
         
         # For continuous futures, resolve to the current active contract
         if asset.asset_type == Asset.AssetType.CONT_FUTURE:
-            # Use Asset class method to resolve continuous futures to actual contract (returns string)
-            resolved_symbol = asset.resolve_continuous_futures_contract(year_digits=1)
+            # Resolve based on reference date when backtesting so we match the contract in use
+            resolved_symbol = _format_futures_symbol_for_databento(
+                asset,
+                reference_date=reference_date,
+            )
             if resolved_symbol is None:
                 logger.error(f"Could not resolve continuous futures contract for {asset.symbol}")
                 return None
-            # Generate the correct DataBento symbol format (should be single result)
             symbols_to_try = _generate_databento_symbol_alternatives(asset.symbol, resolved_symbol)
             logger.info(f"Resolved continuous future {asset.symbol} to specific contract: {resolved_symbol}")
             logger.info(f"DataBento symbol format for last price: {symbols_to_try[0]}")
@@ -1000,12 +1003,17 @@ def get_last_price_from_databento(
             if hasattr(range_result, 'end') and range_result.end:
                 if hasattr(range_result.end, 'tz_localize'):
                     # Already a pandas Timestamp
-                    available_end = range_result.end if range_result.end.tz else range_result.end.tz_localize('UTC')
+                    if range_result.end.tz is not None:
+                        available_end = range_result.end.tz_convert('UTC')
+                    else:
+                        available_end = range_result.end.tz_localize('UTC')
                 else:
                     # Convert to pandas Timestamp
-                    available_end = pd.to_datetime(range_result.end).tz_localize('UTC')
+                    ts = pd.to_datetime(range_result.end)
+                    available_end = ts if ts.tz is not None else ts.tz_localize('UTC')
             elif isinstance(range_result, dict) and 'end' in range_result:
-                available_end = pd.to_datetime(range_result['end']).tz_localize('UTC')
+                ts = pd.to_datetime(range_result['end'])
+                available_end = ts if ts.tz is not None else ts.tz_localize('UTC')
             else:
                 logger.warning(f"Could not parse dataset range for {dataset}: {range_result}")
                 # Fallback: use a recent date that's likely to have data
@@ -1047,10 +1055,10 @@ def get_last_price_from_databento(
                         df = pd.DataFrame(data)
                     
                     if not df.empty:
-                        # Get the last available price (close price of most recent bar)
                         if 'close' in df.columns:
-                            price = df['close'].iloc[-1]
-                            if pd.notna(price):
+                            closes = df['close'].dropna()
+                            if not closes.empty:
+                                price = closes.iloc[-1]
                                 logger.info(f"✓ SUCCESS: Got last price for {symbol_to_use}: {price}")
                                 return float(price)
                         

lumibot/tools/thetadata_helper.py

@@ -2,7 +2,8 @@
 import time
 import os
 import signal
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Tuple
+from collections import defaultdict
 from datetime import date, datetime, timedelta, timezone
 from pathlib import Path
 import pytz
@@ -1883,55 +1884,242 @@ def get_historical_data(asset: Asset, start_dt: datetime, end_dt: datetime, ivl:
     return df
 
 
-def get_expirations(username: str, password: str, ticker: str, after_date: date):
-    """
-    Get a list of expiration dates for the given ticker
+def _normalize_expiration_value(raw_value: object) -> Optional[str]:
+    """Convert ThetaData expiration payloads to ISO date strings."""
+    if raw_value is None or (isinstance(raw_value, float) and pd.isna(raw_value)):
+        return None
 
-    Parameters
-    ----------
-    username : str
-        Your ThetaData username
-    password : str
-        Your ThetaData password
-    ticker : str
-        The ticker for the asset we are getting data for
+    if isinstance(raw_value, (int, float)):
+        try:
+            digits = int(raw_value)
+        except (TypeError, ValueError):
+            return None
+        if digits <= 0:
+            return None
+        text = f"{digits:08d}"
+        return f"{text[0:4]}-{text[4:6]}-{text[6:8]}"
 
-    Returns
-    -------
-    list[str]
-        A list of expiration dates for the given ticker
-    """
-    # Use v2 API endpoint
-    url = f"{BASE_URL}/v2/list/expirations"
+    text_value = str(raw_value).strip()
+    if not text_value:
+        return None
+    if text_value.isdigit() and len(text_value) == 8:
+        return f"{text_value[0:4]}-{text_value[4:6]}-{text_value[6:8]}"
+    if len(text_value.split("-")) == 3:
+        return text_value
+    return None
+
+
+def _normalize_strike_value(raw_value: object) -> Optional[float]:
+    """Convert ThetaData strike payloads to float strikes in dollars."""
+    if raw_value is None or (isinstance(raw_value, float) and pd.isna(raw_value)):
+        return None
+
+    try:
+        strike = float(raw_value)
+    except (TypeError, ValueError):
+        return None
+
+    if strike <= 0:
+        return None
+
+    # ThetaData encodes strikes in thousandths of a dollar for integer payloads
+    if strike > 10000:
+        strike /= 1000.0
+
+    return round(strike, 4)
 
-    querystring = {"root": ticker}
+
+def _detect_column(df: pd.DataFrame, candidates: Tuple[str, ...]) -> Optional[str]:
+    """Find the first column name matching the provided candidates (case-insensitive)."""
+    normalized = {str(col).strip().lower(): col for col in df.columns}
+    for candidate in candidates:
+        lookup = candidate.lower()
+        if lookup in normalized:
+            return normalized[lookup]
+    return None
+
+
+def build_historical_chain(
+    username: str,
+    password: str,
+    asset: Asset,
+    as_of_date: date,
+    max_expirations: int = 120,
+    max_consecutive_misses: int = 10,
+) -> Dict[str, Dict[str, List[float]]]:
+    """Build an as-of option chain by filtering live expirations against quote availability."""
+
+    if as_of_date is None:
+        raise ValueError("as_of_date must be provided to build a historical chain")
 
     headers = {"Accept": "application/json"}
+    expirations_resp = get_request(
+        url=f"{BASE_URL}/v2/list/expirations",
+        headers=headers,
+        querystring={"root": asset.symbol},
+        username=username,
+        password=password,
+    )
 
-    # Send the request
-    json_resp = get_request(url=url, headers=headers, querystring=querystring, username=username, password=password)
+    if not expirations_resp or not expirations_resp.get("response"):
+        logger.warning(
+            "ThetaData returned no expirations for %s; cannot build chain for %s.",
+            asset.symbol,
+            as_of_date,
+        )
+        return None
 
-    # Convert to pandas dataframe
-    df = pd.DataFrame(json_resp["response"], columns=json_resp["header"]["format"])
+    exp_df = pd.DataFrame(expirations_resp["response"], columns=expirations_resp["header"]["format"])
+    if exp_df.empty:
+        logger.warning(
+            "ThetaData returned empty expiration list for %s; cannot build chain for %s.",
+            asset.symbol,
+            as_of_date,
+        )
+        return None
 
-    # Convert df to a list of the first (and only) column
-    expirations = df.iloc[:, 0].tolist()
+    expiration_values: List[int] = sorted(int(value) for value in exp_df.iloc[:, 0].tolist())
+    as_of_int = int(as_of_date.strftime("%Y%m%d"))
 
-    # Convert after_date to a number
-    after_date_int = int(after_date.strftime("%Y%m%d"))
+    chains: Dict[str, Dict[str, List[float]]] = {"CALL": {}, "PUT": {}}
+    expirations_added = 0
+    consecutive_misses = 0
 
-    # Filter out any dates before after_date
-    expirations = [x for x in expirations if x >= after_date_int]
+    def expiration_has_data(expiration_str: str, strike_thousandths: int, right: str) -> bool:
+        querystring = {
+            "root": asset.symbol,
+            "exp": expiration_str,
+            "strike": strike_thousandths,
+            "right": right,
+        }
+        resp = get_request(
+            url=f"{BASE_URL}/list/dates/option/quote",
+            headers=headers,
+            querystring=querystring,
+            username=username,
+            password=password,
+        )
+        if not resp or resp.get("header", {}).get("error_type") == "NO_DATA":
+            return False
+        dates = resp.get("response", [])
+        return as_of_int in dates if dates else False
+
+    for exp_value in expiration_values:
+        if exp_value < as_of_int:
+            continue
+
+        expiration_iso = _normalize_expiration_value(exp_value)
+        if not expiration_iso:
+            continue
 
-    # Convert from "YYYYMMDD" (an int) to "YYYY-MM-DD" (a string)
+        strike_resp = get_request(
+            url=f"{BASE_URL}/v2/list/strikes",
+            headers=headers,
+            querystring={"root": asset.symbol, "exp": str(exp_value)},
+            username=username,
+            password=password,
+        )
+        if not strike_resp or not strike_resp.get("response"):
+            logger.debug(
+                "No strikes for %s exp %s; skipping.",
+                asset.symbol,
+                expiration_iso,
+            )
+            consecutive_misses += 1
+            if consecutive_misses >= max_consecutive_misses:
+                break
+            continue
+
+        strike_df = pd.DataFrame(strike_resp["response"], columns=strike_resp["header"]["format"])
+        if strike_df.empty:
+            consecutive_misses += 1
+            if consecutive_misses >= max_consecutive_misses:
+                break
+            continue
+
+        strike_values = sorted({round(value / 1000.0, 4) for value in strike_df.iloc[:, 0].tolist()})
+        if not strike_values:
+            consecutive_misses += 1
+            if consecutive_misses >= max_consecutive_misses:
+                break
+            continue
+
+        # Use the median strike to validate whether the expiration existed on the backtest date
+        median_index = len(strike_values) // 2
+        probe_strike = strike_values[median_index]
+        probe_thousandths = int(round(probe_strike * 1000))
+
+        has_call_data = expiration_has_data(str(exp_value), probe_thousandths, "C")
+        has_put_data = has_call_data or expiration_has_data(str(exp_value), probe_thousandths, "P")
+
+        if not (has_call_data or has_put_data):
+            logger.debug(
+                "Expiration %s for %s not active on %s; skipping.",
+                expiration_iso,
+                asset.symbol,
+                as_of_date,
+            )
+            consecutive_misses += 1
+            if consecutive_misses >= max_consecutive_misses:
+                logger.debug(
+                    "Encountered %d consecutive inactive expirations for %s; stopping scan.",
+                    max_consecutive_misses,
+                    asset.symbol,
+                )
+                break
+            continue
+
+        chains["CALL"][expiration_iso] = strike_values
+        chains["PUT"][expiration_iso] = list(strike_values)
+        expirations_added += 1
+        consecutive_misses = 0
+
+        if expirations_added >= max_expirations:
+            break
+
+    logger.debug(
+        "Built ThetaData historical chain for %s on %s (expirations=%d)",
+        asset.symbol,
+        as_of_date,
+        expirations_added,
+    )
+
+    if not chains["CALL"] and not chains["PUT"]:
+        logger.warning(
+            "No expirations with data found for %s on %s.",
+            asset.symbol,
+            as_of_date,
+        )
+        return None
+
+    return {
+        "Multiplier": 100,
+        "Exchange": "SMART",
+        "Chains": chains,
+    }
+
+
+def get_expirations(username: str, password: str, ticker: str, after_date: date):
+    """Legacy helper retained for backward compatibility; prefer build_historical_chain."""
+    logger.warning(
+        "get_expirations is deprecated and provides live expirations only. "
+        "Use build_historical_chain for historical backtests (ticker=%s, after=%s).",
+        ticker,
+        after_date,
+    )
+
+    url = f"{BASE_URL}/v2/list/expirations"
+    querystring = {"root": ticker}
+    headers = {"Accept": "application/json"}
+    json_resp = get_request(url=url, headers=headers, querystring=querystring, username=username, password=password)
+    df = pd.DataFrame(json_resp["response"], columns=json_resp["header"]["format"])
+    expirations = df.iloc[:, 0].tolist()
+    after_date_int = int(after_date.strftime("%Y%m%d"))
+    expirations = [x for x in expirations if x >= after_date_int]
     expirations_final = []
     for expiration in expirations:
         expiration_str = str(expiration)
-        # Add the dashes to the string
-        expiration_str = f"{expiration_str[:4]}-{expiration_str[4:6]}-{expiration_str[6:]}"
-        # Add the string to the list
-        expirations_final.append(expiration_str)
-
+        expirations_final.append(f"{expiration_str[:4]}-{expiration_str[4:6]}-{expiration_str[6:]}")
     return expirations_final
 
 
@@ -2017,8 +2205,6 @@ def get_chains_cached(
         }
     }
     """
-    from collections import defaultdict
-
     logger.debug(f"get_chains_cached called for {asset.symbol} on {current_date}")
 
     # 1) If current_date is None => bail out
@@ -2063,28 +2249,32 @@ def get_chains_cached(
 
             return data
 
-    # 4) No suitable file => fetch from ThetaData
-    logger.debug(f"No suitable file found for {asset.symbol} on {current_date}. Downloading...")
-    print(f"\nDownloading option chain for {asset} on {current_date}. This will be cached for future use.")
+    # 4) No suitable file => fetch from ThetaData using exp=0 chain builder
+    logger.debug(
+        f"No suitable cache file found for {asset.symbol} on {current_date}; building historical chain."
+    )
+    print(
+        f"\nDownloading option chain for {asset} on {current_date}. This will be cached for future use."
+    )
 
-    # Get expirations and strikes using existing functions
-    expirations = get_expirations(username, password, asset.symbol, current_date)
+    chains_dict = build_historical_chain(
+        username=username,
+        password=password,
+        asset=asset,
+        as_of_date=current_date,
+    )
 
-    chains_dict = {
-        "Multiplier": 100,
-        "Exchange": "SMART",
-        "Chains": {
-            "CALL": defaultdict(list),
-            "PUT": defaultdict(list)
+    if chains_dict is None:
+        logger.warning(
+            "ThetaData returned no option data for %s on %s; skipping cache write.",
+            asset.symbol,
+            current_date,
+        )
+        return {
+            "Multiplier": 100,
+            "Exchange": "SMART",
+            "Chains": {"CALL": {}, "PUT": {}},
         }
-    }
-
-    for expiration_str in expirations:
-        expiration = date.fromisoformat(expiration_str)
-        strikes = get_strikes(username, password, asset.symbol, expiration)
-
-        chains_dict["Chains"]["CALL"][expiration_str] = sorted(strikes)
-        chains_dict["Chains"]["PUT"][expiration_str] = sorted(strikes)
 
     # 5) Save to cache file for future reuse
     cache_file = chain_folder / f"{asset.symbol}_{current_date.isoformat()}.parquet"

{lumibot-4.2.5.dist-info → lumibot-4.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lumibot
-Version: 4.2.5
+Version: 4.2.7
 Summary: Backtesting and Trading Library, Made by Lumiwealth
 Home-page: https://github.com/Lumiwealth/lumibot
 Author: Robert Grzesik
@@ -51,7 +51,7 @@ Requires-Dist: schwab-py>=1.5.0
 Requires-Dist: Flask>=2.3
 Requires-Dist: free-proxy
 Requires-Dist: requests-oauthlib
-Requires-Dist: boto3>=1.28.0
+Requires-Dist: boto3>=1.40.64
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{lumibot-4.2.5.dist-info → lumibot-4.2.7.dist-info}/RECORD

@@ -7,14 +7,14 @@ lumibot/backtesting/alpha_vantage_backtesting.py,sha256=LR3UNhJrdAKdvadiThVKdKrM
 lumibot/backtesting/backtesting_broker.py,sha256=C0zn__i0aoyd6u147oizRYO2Akqa5JWs8znl6siLd8Y,76003
 lumibot/backtesting/ccxt_backtesting.py,sha256=O-RjuNpx5y4f-hKKwwUbrU7hAVkGEegmnvH_9nQWhAo,246
 lumibot/backtesting/databento_backtesting.py,sha256=zQS6IaamDTQREcjViguk_y4b_HF1xyV3gUrDuHnkUUY,430
-lumibot/backtesting/databento_backtesting_pandas.py,sha256=kK6XXmm9veZSt-z1HBKdEzM_LkrVt2-DVfajtkTDdCI,31229
+lumibot/backtesting/databento_backtesting_pandas.py,sha256=xIQ1SnPo47rxIH7hfrgWzhTuVxxG8LDklY3Z8Tu5idU,32440
 lumibot/backtesting/databento_backtesting_polars.py,sha256=qanSLBsw4aBEFVfMuwSWzTDtaXQlOfcrvp6ERLWkRVo,45786
 lumibot/backtesting/fix_debug.py,sha256=ETHl-O38xK9JOQC2x8IZVJRCQrR1cokk2Vb4vpGMvb8,1204
 lumibot/backtesting/interactive_brokers_rest_backtesting.py,sha256=5HJ_sPX0uOUg-rbfOKDjwYVCLiXevlwtdK_3BcUwqXc,6602
 lumibot/backtesting/pandas_backtesting.py,sha256=m-NvT4o-wFQjaZft6TXULzeZBrskO_7Z-jfy9AIkyAY,388
 lumibot/backtesting/polygon_backtesting.py,sha256=u9kif_2_7k0P4-KDvbHhaMfSoBVejUUX7fh9H3PCVE0,12350
 lumibot/backtesting/thetadata_backtesting.py,sha256=Xcz5f-4zTkKgWWcktNzItH2vrr8CysIMQWKKqLwugbA,345
-lumibot/backtesting/thetadata_backtesting_pandas.py,sha256=3ltwnxqAw4xXG2VOk14G_vpVHAVdnGl10SsveoMoJF0,51844
+lumibot/backtesting/thetadata_backtesting_pandas.py,sha256=4jIxziBASbmCe5MCmjmvQBeo-5EQ90UTmblRpHrAaDE,51829
 lumibot/backtesting/yahoo_backtesting.py,sha256=LT2524mGlrUSq1YSRnUqGW4-Xcq4USgRv2EhnV_zfs4,502
 lumibot/brokers/__init__.py,sha256=MGWKHeH3mqseYRL7u-KX1Jp2x9EaFO4Ol8sfNSxzu1M,404
 lumibot/brokers/alpaca.py,sha256=VQ17idfqiEFb2JCqqdMGmbvF789L7_PpsCbudiFRzmg,61595
@@ -34,7 +34,7 @@ lumibot/components/configs_helper.py,sha256=e4-2jBmjsIDeMQ9fbQ9j2U6WlHCe2z9bIQtJ
 lumibot/components/drift_rebalancer_logic.py,sha256=KL1S9Su5gxibGzl2fw_DH8StzXvjFfFl23sOFGHgIZI,28653
 lumibot/components/grok_helper.py,sha256=vgyPAs63VoNsfZojMoHYRLckb-CFiZkHIlY8HSYZLQs,15382
 lumibot/components/grok_news_helper.py,sha256=7GFtSuRkBo4-3IcUmC6qhuf7iekoVyyP7q5jyUjAWTc,11007
-lumibot/components/options_helper.py,sha256=pUihHFEv5w17pXACE3xw0Tq6tHb9s05fzttlg4hmD7E,64931
+lumibot/components/options_helper.py,sha256=UTMJUrTX9AOq-SPkZR7IFOFc65JQRZDSSrzy6a7ptZY,67371
 lumibot/components/perplexity_helper.py,sha256=0dhAIXunvUnTKIFFdYbFt8adnSIavKRqXkQ91fjsDPI,31432
 lumibot/components/quiver_helper.py,sha256=s0Y-tL1y2S1mYlbtlRTcL5R4WV0HYOgiSJ9hT41Hzrw,14380
 lumibot/components/vix_helper.py,sha256=tsWHFQzOJCjdmSGgmnYIty0K5ua-iAgBiRlyRIpGli0,61940
@@ -104,7 +104,7 @@ lumibot/example_strategies/test_broker_functions.py,sha256=wnVS-M_OtzMgaXVBgshVE
 lumibot/resources/ThetaTerminal.jar,sha256=K6GeeFcN8-gvyL2x5iq5pzD79KfPJvMK8iiezi3TmNQ,11834389
 lumibot/resources/conf.yaml,sha256=rjB9-10JP7saZ_edjX5bQDGfuc3amOQTUUUr-UiMpNA,597
 lumibot/strategies/__init__.py,sha256=jEZ95K5hG0f595EXYKWwL2_UsnWWk5Pug361PK2My2E,79
-lumibot/strategies/_strategy.py,sha256=wWx2te98kwMTuusioKR24KsKW8Djs3yhOb2nNmvgbiU,111467
+lumibot/strategies/_strategy.py,sha256=3Z2MPz3jYgJdAphaFyoEI5OUs_6ClAJgRCrLWy-b2sg,111718
 lumibot/strategies/session_manager.py,sha256=Nze6UYNSPlCsf-tyHvtFqUeL44WSNHjwsKrIepvsyCY,12956
 lumibot/strategies/strategy.py,sha256=toPeL5oIVWmCxBNcfXqIuTCF_EeCfIVj425PrSYImCo,170021
 lumibot/strategies/strategy_executor.py,sha256=AnmXlKD2eMgKXs3TrD1u8T_Zsn_8GnG5KRcM_Pq-JBQ,70749
@@ -113,8 +113,8 @@ lumibot/tools/alpaca_helpers.py,sha256=nhBS-sv28lZfIQ85szC9El8VHLrCw5a5KbsGOOEjm
 lumibot/tools/backtest_cache.py,sha256=A-Juzu0swZI_FP4U7cd7ruYTgJYgV8BPf_WJDI-NtrM,9556
 lumibot/tools/bitunix_helpers.py,sha256=-UzrN3w_Y-Ckvhl7ZBoAcx7sgb6tH0KcpVph1Ovm3gw,25780
 lumibot/tools/black_scholes.py,sha256=TBjJuDTudvqsbwqSb7-zb4gXsJBCStQFaym8xvePAjw,25428
-lumibot/tools/ccxt_data_store.py,sha256=VXLSs0sWcwjRPZzbuEeVPS-3V6D10YnYMfIyoTPTG0U,21225
-lumibot/tools/databento_helper.py,sha256=6jCIh1GlEpdU_copJSNTYmvcIKMXCucaAONwmqQjxCE,43466
+lumibot/tools/ccxt_data_store.py,sha256=PlP3MHPHZP7GisEZsk1OUxeWijoPXwiQbsOBTr7jkQI,21227
+lumibot/tools/databento_helper.py,sha256=WBuQCm9Z7WFpde8qdsJEabtpU0ThGsjjPeK7BI2pUVA,43681
 lumibot/tools/databento_helper_polars.py,sha256=FXvvES_Y-E-IzAmVBtquh1UtQ-eN6i6BEoflcP7y8s0,48674
 lumibot/tools/databento_roll.py,sha256=48HAw3h6OngCK4UTl9ifpjo-ki8qmB6OoJUrHp0gRmE,6767
 lumibot/tools/debugers.py,sha256=ga6npFsS9cpKtTXaygh9t2_txCElg3bfzfeqDBvSL8k,485
@@ -132,7 +132,7 @@ lumibot/tools/polygon_helper_async.py,sha256=YHDXa9kmkkn8jh7hToY6GP5etyXS9Tj-uky
 lumibot/tools/polygon_helper_polars_optimized.py,sha256=NaIZ-5Av-G2McPEKHyJ-x65W72W_Agnz4lRgvXfQp8c,30415
 lumibot/tools/projectx_helpers.py,sha256=EIemLfbG923T_RBV_i6s6A9xgs7dt0et0oCnhFwdWfA,58299
 lumibot/tools/schwab_helper.py,sha256=CXnYhgsXOIb5MgmIYOp86aLxsBF9oeVrMGrjwl_GEv0,11768
-lumibot/tools/thetadata_helper.py,sha256=Guutp_2QAZe22_r6pftCojpTb3DpDp4Ul_szf6N7X1I,80152
+lumibot/tools/thetadata_helper.py,sha256=QXuFzfHi22L9sqzwL_mXZGhU2m9ortbE9U1-Kt7jSew,86743
 lumibot/tools/types.py,sha256=x-aQBeC6ZTN2-pUyxyo69Q0j5e0c_swdfe06kfrWSVc,1978
 lumibot/tools/yahoo_helper.py,sha256=htcKKkuktatIckVKfLc_ms0X75mXColysQhrZW244z8,19497
 lumibot/tools/yahoo_helper_polars_optimized.py,sha256=g9xBN-ReHSW4Aj9EMU_OncBXVS1HpfL8LTHit9ZxFY4,7417
@@ -142,7 +142,7 @@ lumibot/traders/trader.py,sha256=KMif3WoZtnSxA0BzoK3kvkTITNELrDFIortx1BYBv8s,967
 lumibot/trading_builtins/__init__.py,sha256=vH2QL5zLjL3slfEV1YW-BvQHtEYLCFkIWTZDfh3y8LE,87
 lumibot/trading_builtins/custom_stream.py,sha256=8_XiPT0JzyXrgnXCXoovGGUrWEfnG4ohIYMPfB_Nook,5264
 lumibot/trading_builtins/safe_list.py,sha256=IIjZOHSiZYK25A4WBts0oJaZNOJDsjZL65MOSHhE3Ig,1975
-lumibot-4.2.5.dist-info/licenses/LICENSE,sha256=fYhGIyxjyNXACgpNQS3xxpxDOaVOWRVxZMCRbsDv8k0,35130
+lumibot-4.2.7.dist-info/licenses/LICENSE,sha256=fYhGIyxjyNXACgpNQS3xxpxDOaVOWRVxZMCRbsDv8k0,35130
 tests/__init__.py,sha256=3-VoT-nAuqMfwufd4ceN6fXaHl_zCfDCSXJOTp1ywYQ,393
 tests/conftest.py,sha256=UBw_2fx7r6TZPKus2b1Qxrzmd4bg8EEBnX1vCHUuSVA,3311
 tests/fixtures.py,sha256=wOHQsh1SGHnXe_PGi6kDWI30CS_Righi7Ig7vwSEKT4,9082
@@ -208,7 +208,7 @@ tests/test_lumibot_logger.py,sha256=76e5yl86NWk4OYtM_be-7yaHnPA-1bO2rBNH-piX8Dk,
 tests/test_market_infinite_loop_bug.py,sha256=p8Wiq2sdNFYOH54Ij9MkDFWBLTC8V3vbJEphcPq6T8g,16181
 tests/test_mes_symbols.py,sha256=Av5AM-pogp1STfWZ4A3bA2NmbaA3E9b0Dg449mfk-Ss,3106
 tests/test_momentum.py,sha256=oakKjgnz5pNQkw0CagbbKKSux0HkOxP_iLW8-Yk0XOo,8492
-tests/test_options_helper.py,sha256=NizH8E9ZnzVWsShsHp5X6qBE8FWJ3sS2eE9bCko7y9U,27352
+tests/test_options_helper.py,sha256=wVXafXP4KfL3T-u9dFjJZbGI9YOHApohW-NfQ36yTuk,29185
 tests/test_options_helper_enhancements.py,sha256=3Ei-vy9IQfg1AnlBqofLNc-kuiQ64vouhJyIuVj3KIg,7324
 tests/test_order.py,sha256=qN_sqsItl8L-WqSQTF0PUN0s2nxm4HKYOA6gYQ6EBJA,12110
 tests/test_order_serialization.py,sha256=zcX5fgcYeo0jm6dlIQnUfuH56svTnKRFPtYCSI7xCJw,3710
@@ -226,7 +226,7 @@ tests/test_projectx_helpers.py,sha256=mKFcWZ7C2ve6UXk2LaJWo1E6QwhU09dkIYht1LElQW
 tests/test_projectx_lifecycle.py,sha256=F7H08wg2b5lYh0vNzKNa5AkQnhCuTrbpPm0YvOZHN6A,3179
 tests/test_projectx_lifecycle_unit.py,sha256=XqktdtFMS4s5RIF2ay9uZNW9Ij1AQL46OUbgStA9rhA,21926
 tests/test_projectx_live_flow.py,sha256=vKnb_VDKCOAbmOdQ5TlyQroCNtNE8UFjHKcd-YpIjXg,412
-tests/test_projectx_timestep_alias.py,sha256=vMf80illnTrwgl09wzGQ99CiTAVgIt2jSfHZELxxEEA,2042
+tests/test_projectx_timestep_alias.py,sha256=Kcq-q9-pB9h9mBSol_qb_VCztVdLItY8xClroGNf3zo,2043
 tests/test_projectx_url_mappings.py,sha256=1E0xZe_cZtGiU-fPIfohbvsrrPjawkblR8F2Mvu_Ct8,10039
 tests/test_quiet_logs_buy_and_hold.py,sha256=GjXGeHBcNrRJoHGWLuc_LkrzcpNVzshiiBkQACczIxI,2681
 tests/test_quiet_logs_comprehensive.py,sha256=QVkZWLAUnPEb04Ec8qKXvLzdDUkp8alez2mU_Y1Umm0,6068
@@ -234,8 +234,9 @@ tests/test_quiet_logs_functionality.py,sha256=MlOBUICuTy1OXCDifOW05uD7hjnZRsQ2xx
 tests/test_quiet_logs_requirements.py,sha256=YoUooSVLrFL8TlWPfxEiqxvSj4d8z6-qg58ja4dtOc0,7856
 tests/test_session_manager.py,sha256=1qygN3aQ2Xe2uh4BMPm0E3V8KXLFNGq5qdL8KkZjef4,11632
 tests/test_strategy_methods.py,sha256=j9Mhr6nnG1fkiVQXnx7gLjzGbeQmwt0UbJr_4plD36o,12539
+tests/test_strategy_price_guard.py,sha256=3GJdlfROwx6-adsSi8ZBrWaLOy9e-0N6V1eqpikj8e4,1540
 tests/test_thetadata_backwards_compat.py,sha256=RzNLhNZNJZ2hPkEDyG-T_4mRRXh5XqavK6r-OjfRASQ,3306
-tests/test_thetadata_helper.py,sha256=l77ksu70knZBudfrMAOwT9zJ91AxX5UgazqvYSrotqM,59346
+tests/test_thetadata_helper.py,sha256=RQ-q7OfKc_2aO7-dInaVRTUrrI5iTh9oteYsdmfn4Lg,63735
 tests/test_thetadata_pandas_verification.py,sha256=MWUecqBY6FGFslWLRo_C5blGbom_unmXCZikAfZXLks,6553
 tests/test_tradier.py,sha256=iCEM2FTxJSzJ2oLNaRqSx05XaX_DCiMzLx1aEYPANko,33280
 tests/test_tradier_data.py,sha256=1jTxDzQtzaC42CQJVXMRMElBwExy1mVci3NFfKjjVH0,13363
@@ -281,7 +282,7 @@ tests/backtest/test_thetadata.py,sha256=xWYfC9C4EhbMDb29qyZWHO3sSWaLIPzzvcMbHCt5
 tests/backtest/test_thetadata_comprehensive.py,sha256=-gN3xLJcJtlB-k4vlaK82DCZDGDmr0LNZZDzn-aN3l4,26120
 tests/backtest/test_thetadata_vs_polygon.py,sha256=dZqsrOx3u3cz-1onIO6o5BDRjI1ey7U9vIkZupfXoig,22831
 tests/backtest/test_yahoo.py,sha256=2FguUTUMC9_A20eqxnZ17rN3tT9n6hyvJHaL98QKpqY,3443
-lumibot-4.2.5.dist-info/METADATA,sha256=lK1f_O0TcWv79IUVPehgpO2s_dQE1jrsj69_LCqeKM8,12092
-lumibot-4.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lumibot-4.2.5.dist-info/top_level.txt,sha256=otUnUjDFVASauEDiTiAzNgMyqQ1B6jjS3QqqP-WSx38,14
-lumibot-4.2.5.dist-info/RECORD,,
+lumibot-4.2.7.dist-info/METADATA,sha256=cCEnxjhYBqtO5Uvd2pEJ90ULy2OlCiX1FHSaJPEpXAI,12093
+lumibot-4.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lumibot-4.2.7.dist-info/top_level.txt,sha256=otUnUjDFVASauEDiTiAzNgMyqQ1B6jjS3QqqP-WSx38,14
+lumibot-4.2.7.dist-info/RECORD,,

tests/test_options_helper.py

@@ -11,7 +11,7 @@ import pytest
 # Add the lumibot path
 sys.path.insert(0, '/Users/robertgrzesik/Documents/Development/lumivest_bot_server/strategies/lumibot')
 
-from lumibot.components.options_helper import OptionsHelper
+from lumibot.components.options_helper import OptionsHelper, OptionMarketEvaluation
 from lumibot.entities import Asset
 from lumibot.entities.chains import OptionsDataFormatError, normalize_option_chains
 from lumibot.brokers.broker import Broker
@@ -311,7 +311,7 @@ class TestOptionsHelper(unittest.TestCase):
         result = self.options_helper.get_expiration_on_or_after_date(target, expiries, "call")
         self.assertEqual(result, _date(2024, 1, 9))
 
-    def test_get_expiration_on_or_after_date_uses_latest_when_needed(self):
+    def test_get_expiration_on_or_after_date_returns_none_when_no_future_available(self):
         from datetime import date as _date
 
         expiries = {
@@ -325,7 +325,7 @@ class TestOptionsHelper(unittest.TestCase):
 
         target = _date(2024, 2, 1)
         result = self.options_helper.get_expiration_on_or_after_date(target, expiries, "call")
-        self.assertEqual(result, _date(2024, 1, 9))
+        self.assertIsNone(result)
 
     def test_chains_backward_compatibility_string_access(self):
         """Test that existing code using string keys still works."""
@@ -676,6 +676,48 @@ class TestOptionsHelper(unittest.TestCase):
         self.assertIsNone(evaluation.sell_price)
         self.assertFalse(evaluation.used_last_price_fallback)
 
+    def test_evaluate_option_market_rejects_non_finite_quotes(self):
+        """NaN or infinite quotes are treated as missing to prevent crashes."""
+        option_asset = Asset(
+            "TEST",
+            asset_type=Asset.AssetType.OPTION,
+            expiration=date.today() + timedelta(days=7),
+            strike=200,
+            right="call",
+            underlying_asset=Asset("TEST", asset_type=Asset.AssetType.STOCK),
+        )
+
+        self.mock_strategy.get_quote.return_value = Mock(bid=float("nan"), ask=float("inf"))
+        self.mock_strategy.get_last_price.return_value = float("nan")
+        self.mock_strategy.broker.data_source.option_quote_fallback_allowed = True
+
+        evaluation = self.options_helper.evaluate_option_market(option_asset, max_spread_pct=0.25)
+
+        self.assertIsNone(evaluation.buy_price)
+        self.assertIn("bid_non_finite", evaluation.data_quality_flags)
+        self.assertIn("ask_non_finite", evaluation.data_quality_flags)
+        self.assertTrue(evaluation.missing_bid_ask)
+        self.assertFalse(OptionsHelper.has_actionable_price(evaluation))
+
+    def test_has_actionable_price_requires_positive_finite_value(self):
+        """has_actionable_price returns False for zero or negative values."""
+        evaluation = OptionMarketEvaluation(
+            bid=0.5,
+            ask=0.6,
+            last_price=0.55,
+            spread_pct=0.18,
+            has_bid_ask=True,
+            spread_too_wide=False,
+            missing_bid_ask=False,
+            missing_last_price=False,
+            buy_price=0.0,
+            sell_price=0.4,
+            used_last_price_fallback=False,
+            max_spread_pct=0.25,
+            data_quality_flags=["buy_price_non_positive"],
+        )
+        self.assertFalse(OptionsHelper.has_actionable_price(evaluation))
+
 if __name__ == "__main__":
     print("🧪 Running enhanced options helper tests...")
     unittest.main(verbosity=2)

tests/test_projectx_timestep_alias.py

@@ -9,7 +9,7 @@ from lumibot.data_sources.projectx_data import ProjectXData
 class DummyClient:
     def history_retrieve_bars(self, contract_id, start_datetime, end_datetime, unit, unit_number, limit, include_partial_bar, live, is_est):
         # Return a minimal DataFrame resembling expected structure
-        idx = pd.date_range(end=end_datetime, periods=unit_number, freq='T')
+        idx = pd.date_range(end=end_datetime, periods=unit_number, freq='min')
         data = {
             'open': [1.0]*len(idx),
             'high': [1.1]*len(idx),
@@ -51,4 +51,3 @@ def test_projectx_get_bars_accepts_timestep_alias(projectx):
     bars_map2 = projectx.get_bars(asset, 1, timestep='minute')
     bars2 = list(bars_map2.values())[0]
     assert bars2 is not None and not bars2.df.empty
-

tests/test_strategy_price_guard.py

@@ -0,0 +1,50 @@
+import math
+from lumibot.components.options_helper import OptionsHelper, OptionMarketEvaluation
+
+
+class _GuardedStrategy:
+    def __init__(self):
+        self.logged = []
+        self.options_helper = OptionsHelper(self)
+
+    def log_message(self, message, color="white"):
+        self.logged.append((color, message))
+
+    def get_cash(self):
+        return 10_000.0
+
+    def size_position(self, evaluation: OptionMarketEvaluation):
+        if evaluation.spread_too_wide or not self.options_helper.has_actionable_price(evaluation):
+            self.log_message(
+                f"Skipping trade due to invalid quotes (flags={evaluation.data_quality_flags}).",
+                color="yellow",
+            )
+            return 0
+
+        buy_price = float(evaluation.buy_price)
+        budget = self.get_cash() * 0.1
+        return math.floor(budget / (buy_price * 100.0))
+
+
+def test_strategy_guard_skips_non_finite_prices():
+    strategy = _GuardedStrategy()
+    evaluation = OptionMarketEvaluation(
+        bid=None,
+        ask=None,
+        last_price=None,
+        spread_pct=None,
+        has_bid_ask=False,
+        spread_too_wide=False,
+        missing_bid_ask=True,
+        missing_last_price=True,
+        buy_price=float("nan"),
+        sell_price=None,
+        used_last_price_fallback=False,
+        max_spread_pct=None,
+        data_quality_flags=["buy_price_non_finite"],
+    )
+
+    contracts = strategy.size_position(evaluation)
+
+    assert contracts == 0
+    assert any("invalid quotes" in msg for _, msg in strategy.logged)

tests/test_thetadata_helper.py

@@ -138,7 +138,11 @@ def test_get_price_data_partial_cache_hit(mock_build_cache_filename, mock_load_c
     assert df is not None
     assert len(df) == 10  # Combined cached and fetched data
     mock_get_historical_data.assert_called_once()
-    pd.testing.assert_frame_equal(df, updated_data.drop(columns="missing"))
+    pd.testing.assert_frame_equal(
+        df,
+        updated_data.drop(columns="missing"),
+        check_dtype=False,
+    )
     mock_update_cache.assert_called_once()
 
 
@@ -452,7 +456,7 @@ def test_get_price_data_invokes_remote_cache_manager(tmp_path, monkeypatch):
 
     df = pd.DataFrame(
         {
-            "datetime": pd.date_range("2024-01-01 09:30:00", periods=2, freq="T", tz=pytz.UTC),
+            "datetime": pd.date_range("2024-01-01 09:30:00", periods=2, freq="min", tz=pytz.UTC),
             "open": [100.0, 101.0],
             "high": [101.0, 102.0],
             "low": [99.5, 100.5],
@@ -1330,83 +1334,203 @@ class TestThetaDataProcessHealthCheck:
         assert thetadata_helper.is_process_alive() is True, "New process should be alive"
 
 
-@pytest.mark.apitest
 class TestThetaDataChainsCaching:
-    """Test option chain caching matches Polygon pattern - ZERO TOLERANCE."""
+    """Unit coverage for historical chain caching and normalization."""
+
+    def test_chains_cached_basic_structure(self, tmp_path, monkeypatch):
+        asset = Asset("TEST", asset_type="stock")
+        test_date = date(2024, 11, 7)
+
+        sample_chain = {
+            "Multiplier": 100,
+            "Exchange": "SMART",
+            "Chains": {
+                "CALL": {"2024-11-15": [100.0, 105.0]},
+                "PUT": {"2024-11-15": [90.0, 95.0]},
+            },
+        }
 
-    def test_chains_cached_basic_structure(self):
-        """Test chain caching returns correct structure."""
-        username = os.environ.get("THETADATA_USERNAME")
-        password = os.environ.get("THETADATA_PASSWORD")
+        calls = []
 
-        asset = Asset("SPY", asset_type="stock")
-        test_date = date(2025, 9, 15)
+        def fake_builder(**kwargs):
+            calls.append(kwargs)
+            return sample_chain
 
-        chains = thetadata_helper.get_chains_cached(username, password, asset, test_date)
+        monkeypatch.setattr(thetadata_helper, "build_historical_chain", fake_builder)
+        monkeypatch.setattr(thetadata_helper, "LUMIBOT_CACHE_FOLDER", str(tmp_path))
 
-        assert chains is not None, "Chains should not be None"
-        assert "Multiplier" in chains, "Missing Multiplier"
-        assert chains["Multiplier"] == 100, f"Multiplier should be 100, got {chains['Multiplier']}"
-        assert "Exchange" in chains, "Missing Exchange"
-        assert "Chains" in chains, "Missing Chains"
-        assert "CALL" in chains["Chains"], "Missing CALL chains"
-        assert "PUT" in chains["Chains"], "Missing PUT chains"
+        result = thetadata_helper.get_chains_cached("user", "pass", asset, test_date)
 
-        # Verify at least one expiration exists
-        assert len(chains["Chains"]["CALL"]) > 0, "Should have at least one CALL expiration"
-        assert len(chains["Chains"]["PUT"]) > 0, "Should have at least one PUT expiration"
+        assert result == sample_chain
+        assert len(calls) == 1
+        builder_call = calls[0]
+        assert builder_call["asset"] == asset
+        assert builder_call["as_of_date"] == test_date
 
-        print(f"✓ Chain structure valid: {len(chains['Chains']['CALL'])} expirations")
+    def test_chains_cache_reuse(self, tmp_path, monkeypatch):
+        asset = Asset("REUSE", asset_type="stock")
+        test_date = date(2024, 11, 8)
 
-    def test_chains_cache_reuse(self):
-        """Test that second call reuses cached data (no API call)."""
-        import time
-        from pathlib import Path
-        from lumibot.constants import LUMIBOT_CACHE_FOLDER
+        sample_chain = {
+            "Multiplier": 100,
+            "Exchange": "SMART",
+            "Chains": {"CALL": {"2024-11-22": [110.0]}, "PUT": {"2024-11-22": [95.0]}},
+        }
 
-        username = os.environ.get("THETADATA_USERNAME")
-        password = os.environ.get("THETADATA_PASSWORD")
+        call_count = {"total": 0}
 
-        asset = Asset("AAPL", asset_type="stock")
-        test_date = date(2025, 9, 15)
+        def fake_builder(**kwargs):
+            call_count["total"] += 1
+            return sample_chain
 
-        # CLEAR CACHE to ensure first call downloads fresh data
-        # This prevents cache pollution from previous tests in the suite
-        # Chains are stored in: LUMIBOT_CACHE_FOLDER / "thetadata" / "option" / "option_chains"
-        chain_folder = Path(LUMIBOT_CACHE_FOLDER) / "thetadata" / "option" / "option_chains"
-        if chain_folder.exists():
-            # Delete all AAPL chain cache files
-            for cache_file in chain_folder.glob("AAPL_*.parquet"):
-                try:
-                    cache_file.unlink()
-                except Exception:
-                    pass
-
-        # Restart ThetaData Terminal to ensure fresh connection after cache clearing
-        # This is necessary because cache clearing may interfere with active connections
-        thetadata_helper.start_theta_data_client(username, password)
-        time.sleep(3)  # Give Terminal time to fully connect
+        monkeypatch.setattr(thetadata_helper, "build_historical_chain", fake_builder)
+        monkeypatch.setattr(thetadata_helper, "LUMIBOT_CACHE_FOLDER", str(tmp_path))
+
+        first = thetadata_helper.get_chains_cached("user", "pass", asset, test_date)
+        second = thetadata_helper.get_chains_cached("user", "pass", asset, test_date)
+
+        assert first == sample_chain
+        assert second == sample_chain
+        assert call_count["total"] == 1, "Builder should only run once due to cache reuse"
+
+    def test_chain_cache_respects_recent_file(self, tmp_path, monkeypatch):
+        asset = Asset("RECENT", asset_type="stock")
+        test_date = date(2024, 11, 30)
+
+        sample_chain = {
+            "Multiplier": 100,
+            "Exchange": "SMART",
+            "Chains": {"CALL": {"2024-12-06": [120.0]}, "PUT": {"2024-12-06": [80.0]}},
+        }
+
+        monkeypatch.setattr(thetadata_helper, "LUMIBOT_CACHE_FOLDER", str(tmp_path))
+
+        cache_folder = Path(tmp_path) / "thetadata" / "stock" / "option_chains"
+        cache_folder.mkdir(parents=True, exist_ok=True)
+
+        cache_file = cache_folder / f"{asset.symbol}_{test_date.isoformat()}.parquet"
+        pd.DataFrame({"data": [sample_chain]}).to_parquet(cache_file, compression="snappy", engine="pyarrow")
+
+        # Builder should not be invoked because cache hit satisfies tolerance window
+        def fail_builder(**kwargs):
+            raise AssertionError("build_historical_chain should not be called when cache is fresh")
+
+        monkeypatch.setattr(thetadata_helper, "build_historical_chain", fail_builder)
+
+        result = thetadata_helper.get_chains_cached("user", "pass", asset, test_date)
+        assert result == sample_chain
+
+    def test_chains_cached_handles_none_builder(self, tmp_path, monkeypatch, caplog):
+        asset = Asset("NONE", asset_type="stock")
+        test_date = date(2024, 11, 28)
+
+        monkeypatch.setattr(thetadata_helper, "build_historical_chain", lambda **kwargs: None)
+        monkeypatch.setattr(thetadata_helper, "LUMIBOT_CACHE_FOLDER", str(tmp_path))
+
+        with caplog.at_level(logging.WARNING):
+            result = thetadata_helper.get_chains_cached("user", "pass", asset, test_date)
+
+        cache_folder = Path(tmp_path) / "thetadata" / "stock" / "option_chains"
+        assert not cache_folder.exists() or not list(cache_folder.glob("*.parquet"))
+
+        assert result == {
+            "Multiplier": 100,
+            "Exchange": "SMART",
+            "Chains": {"CALL": {}, "PUT": {}},
+        }
+        assert "ThetaData returned no option data" in caplog.text
+
+
+def test_build_historical_chain_parses_quote_payload(monkeypatch):
+    asset = Asset("CVNA", asset_type="stock")
+    as_of_date = date(2024, 11, 7)
+    as_of_int = int(as_of_date.strftime("%Y%m%d"))
+
+    def fake_get_request(url, headers, querystring, username, password):
+        if url.endswith("/v2/list/expirations"):
+            return {
+                "header": {"format": ["date"]},
+                "response": [[20241115], [20241205], [20250124]],
+            }
+        if url.endswith("/v2/list/strikes"):
+            exp = querystring["exp"]
+            if exp == "20241115":
+                return {
+                    "header": {"format": ["strike"]},
+                    "response": [[100000], [105000]],
+                }
+            if exp == "20241205":
+                return {
+                    "header": {"format": ["strike"]},
+                    "response": [[110000]],
+                }
+            return {
+                "header": {"format": ["strike"]},
+                "response": [[120000]],
+            }
+        if url.endswith("/list/dates/option/quote"):
+            exp = querystring["exp"]
+            if exp == "20241115":
+                return {
+                    "header": {"format": None, "error_type": "null"},
+                    "response": [as_of_int, as_of_int + 1],
+                }
+            return {
+                "header": {"format": None, "error_type": "NO_DATA"},
+                "response": [],
+            }
+        raise AssertionError(f"Unexpected URL {url}")
+
+    monkeypatch.setattr(thetadata_helper, "get_request", fake_get_request)
+
+    result = thetadata_helper.build_historical_chain("user", "pass", asset, as_of_date)
+
+    assert result["Multiplier"] == 100
+    assert set(result["Chains"].keys()) == {"CALL", "PUT"}
+    assert list(result["Chains"]["CALL"].keys()) == ["2024-11-15"]
+    assert result["Chains"]["CALL"]["2024-11-15"] == [100.0, 105.0]
+    assert result["Chains"]["PUT"]["2024-11-15"] == [100.0, 105.0]
+
+
+def test_build_historical_chain_returns_none_when_no_dates(monkeypatch, caplog):
+    asset = Asset("NONE", asset_type="stock")
+    as_of_date = date(2024, 11, 28)
+
+    as_of_int = int(as_of_date.strftime("%Y%m%d"))
+
+    def fake_get_request(url, headers, querystring, username, password):
+        if url.endswith("/v2/list/expirations"):
+            return {"header": {"format": ["date"]}, "response": [[20241129], [20241206]]}
+        if url.endswith("/v2/list/strikes"):
+            return {"header": {"format": ["strike"]}, "response": [[150000], [155000]]}
+        if url.endswith("/list/dates/option/quote"):
+            return {"header": {"format": None, "error_type": "NO_DATA"}, "response": []}
+        raise AssertionError(f"Unexpected URL {url}")
+
+    monkeypatch.setattr(thetadata_helper, "get_request", fake_get_request)
+
+    with caplog.at_level(logging.WARNING):
+        result = thetadata_helper.build_historical_chain("user", "pass", asset, as_of_date)
+
+    assert result is None
+    assert f"No expirations with data found for {asset.symbol}" in caplog.text
 
-        # Verify connection is established
-        _, connected = thetadata_helper.check_connection(username, password)
-        assert connected, "ThetaData Terminal failed to connect"
+def test_build_historical_chain_empty_response(monkeypatch, caplog):
+    asset = Asset("EMPTY", asset_type="stock")
+    as_of_date = date(2024, 11, 9)
 
-        # First call - downloads (now guaranteed to be fresh)
-        start1 = time.time()
-        chains1 = thetadata_helper.get_chains_cached(username, password, asset, test_date)
-        time1 = time.time() - start1
+    def fake_get_request(url, headers, querystring, username, password):
+        if url.endswith("/v2/list/expirations"):
+            return {"header": {"format": ["date"]}, "response": []}
+        raise AssertionError("Unexpected call after empty expirations")
 
-        # Second call - should use cache
-        start2 = time.time()
-        chains2 = thetadata_helper.get_chains_cached(username, password, asset, test_date)
-        time2 = time.time() - start2
+    monkeypatch.setattr(thetadata_helper, "get_request", fake_get_request)
 
-        # Verify same data
-        assert chains1 == chains2, "Cached chains should match original"
+    with caplog.at_level(logging.WARNING):
+        result = thetadata_helper.build_historical_chain("user", "pass", asset, as_of_date)
 
-        # Second call should be MUCH faster (cached)
-        assert time2 < time1 * 0.1, f"Cache not working: time1={time1:.2f}s, time2={time2:.2f}s (should be 10x faster)"
-        print(f"✓ Cache speedup: {time1/time2:.1f}x faster ({time1:.2f}s -> {time2:.4f}s)")
+    assert result is None
+    assert "returned no expirations" in caplog.text
 
 
 def test_finalize_day_frame_handles_dst_fallback():