lumibot 4.2.4__tar.gz → 4.2.6__tar.gz

{lumibot-4.2.4/lumibot.egg-info → lumibot-4.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lumibot
-Version: 4.2.4
+Version: 4.2.6
 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.4 → lumibot-4.2.6}/lumibot/backtesting/databento_backtesting_pandas.py

@@ -454,9 +454,9 @@ 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

{lumibot-4.2.4 → lumibot-4.2.6}/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-4.2.4 → lumibot-4.2.6}/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-4.2.4 → lumibot-4.2.6}/lumibot/strategies/_strategy.py

@@ -124,6 +124,23 @@ class Vars:
 
 
 class _Strategy:
+    @staticmethod
+    def _normalize_backtest_datetime(value):
+        """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
+        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:
         """Boolean flag indicating whether the strategy is running in backtesting mode."""
@@ -1389,8 +1406,8 @@ class _Strategy:
             raise ValueError(f"`optionsource_class` must be a class. You passed in {optionsource_class}")
 
         try:
-            backtesting_start = to_datetime_aware(backtesting_start)
-            backtesting_end = to_datetime_aware(backtesting_end)
+            backtesting_start = self._normalize_backtest_datetime(backtesting_start)
+            backtesting_end = self._normalize_backtest_datetime(backtesting_end)
         except AttributeError:
             get_logger(__name__).error(
                 "`backtesting_start` and `backtesting_end` must be datetime objects. \n"
@@ -1399,6 +1416,9 @@ class _Strategy:
             )
             return None
 
+        get_logger(__name__).info("Backtest start = %s", backtesting_start)
+        get_logger(__name__).info("Backtest end = %s", backtesting_end)
+
         self.verify_backtest_inputs(backtesting_start, backtesting_end)
 
         if not self.IS_BACKTESTABLE:
@@ -1628,8 +1648,8 @@ class _Strategy:
         if not isinstance(backtesting_end, datetime.datetime):
             raise ValueError(f"`backtesting_end` must be a datetime object. You passed in {backtesting_end}")
 
-        start_dt = to_datetime_aware(backtesting_start)
-        end_dt = to_datetime_aware(backtesting_end)
+        start_dt = cls._normalize_backtest_datetime(backtesting_start)
+        end_dt = cls._normalize_backtest_datetime(backtesting_end)
 
         # Check that backtesting end is after backtesting start
         if end_dt <= start_dt:

{lumibot-4.2.4 → lumibot-4.2.6}/lumibot/strategies/strategy_executor.py

@@ -13,8 +13,6 @@ import pandas_market_calendars as mcal
 from apscheduler.jobstores.memory import MemoryJobStore
 from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.triggers.cron import CronTrigger
-from termcolor import colored
-
 from lumibot.constants import LUMIBOT_DEFAULT_PYTZ
 from lumibot.entities import Asset, Order
 from lumibot.entities import Asset
@@ -1166,7 +1164,7 @@ class StrategyExecutor(Thread):
                 # For live trading, stop when market closes
                 return False
 
-        self.strategy.log_message(colored(f"Sleeping for {strategy_sleeptime} seconds", color="blue"))
+        self.strategy.logger.debug("Sleeping for %s seconds", strategy_sleeptime)
 
         # Run process orders at the market close time first (if not continuous market)
         if not is_continuous_market:

{lumibot-4.2.4 → lumibot-4.2.6}/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-4.2.4 → lumibot-4.2.6}/lumibot/tools/databento_helper.py

@@ -1047,10 +1047,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)