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

lumibot/data_sources/databento_data_polars.py

@@ -24,8 +24,13 @@ except ImportError:  # pragma: no cover - optional dependency
 from .data_source import DataSource
 from .polars_mixin import PolarsMixin
 from lumibot.entities import Asset, Bars, Quote
-from lumibot.tools import databento_helper_polars
-from lumibot.tools.databento_helper_polars import _ensure_polars_datetime_timezone as _ensure_polars_tz
+from lumibot.tools import databento_helper_polars, futures_roll
+from lumibot.tools.databento_helper_polars import (
+    _ensure_polars_datetime_timezone as _ensure_polars_tz,
+    _ensure_polars_datetime_precision as _ensure_polars_precision,
+    _format_futures_symbol_for_databento,
+    _generate_databento_symbol_alternatives,
+)
 from lumibot.tools.lumibot_logger import get_logger
 
 logger = get_logger(__name__)
@@ -455,6 +460,7 @@ class DataBentoDataPolars(PolarsMixin, DataSource):
         
         df = pl.DataFrame(tail_bars).sort('datetime')
         df = _ensure_polars_tz(df)
+        df = _ensure_polars_precision(df)
         logger.debug(f"[DATABENTO][LIVE] Collected {len(df)} tail bars after {after_dt}")
         return df
 
@@ -512,38 +518,30 @@ class DataBentoDataPolars(PolarsMixin, DataSource):
     
     def _resolve_futures_symbol(self, asset: Asset, reference_date: datetime = None) -> str:
         """Resolve asset to specific futures contract symbol"""
-        if asset.asset_type in [Asset.AssetType.FUTURE, Asset.AssetType.CONT_FUTURE]:
-            # For continuous futures, resolve to specific contract
-            if asset.asset_type == Asset.AssetType.CONT_FUTURE:
-                if hasattr(asset, 'resolve_continuous_futures_contract'):
-                    return asset.resolve_continuous_futures_contract(
-                        reference_date=reference_date,
-                        year_digits=1,
-                    )
-            
-            # Manual resolution for common futures
-            symbol = asset.symbol.upper()
-            month = reference_date.month if reference_date else datetime.now().month
-            year = reference_date.year if reference_date else datetime.now().year
-            
-            # Quarterly contracts
-            if month <= 3:
-                month_code = 'H'
-            elif month <= 6:
-                month_code = 'M'
-            elif month <= 9:
-                month_code = 'U'
-            else:
-                month_code = 'Z'
-            
-            year_digit = year % 10
-            
-            if symbol in ["ES", "NQ", "RTY", "YM", "MES", "MNQ", "MYM", "M2K", "CL", "GC", "SI"]:
-                return f"{symbol}{month_code}{year_digit}"
-            
+        if asset.asset_type not in [Asset.AssetType.FUTURE, Asset.AssetType.CONT_FUTURE]:
             return asset.symbol
-        
-        return asset.symbol
+
+        ref_dt = reference_date or datetime.now(timezone.utc)
+
+        if asset.asset_type == Asset.AssetType.FUTURE and asset.expiration:
+            return _format_futures_symbol_for_databento(asset, reference_date=reference_date)
+
+        if asset.asset_type == Asset.AssetType.CONT_FUTURE:
+            resolved_contract = futures_roll.resolve_symbol_for_datetime(
+                asset,
+                ref_dt,
+                year_digits=2,
+            )
+        else:
+            temp_asset = Asset(asset.symbol, Asset.AssetType.CONT_FUTURE)
+            resolved_contract = futures_roll.resolve_symbol_for_datetime(
+                temp_asset,
+                ref_dt,
+                year_digits=2,
+            )
+
+        databento_symbol = _generate_databento_symbol_alternatives(asset.symbol, resolved_contract)
+        return databento_symbol[0] if databento_symbol else resolved_contract
     
     def get_historical_prices(
         self,
@@ -633,6 +631,8 @@ class DataBentoDataPolars(PolarsMixin, DataSource):
                             
                             df = _ensure_polars_tz(df)
                             tail_df = _ensure_polars_tz(tail_df)
+                            df = _ensure_polars_precision(df)
+                            tail_df = _ensure_polars_precision(tail_df)
 
                             # Only keep columns that exist in both dataframes
                             common_columns = [col for col in df.columns if col in tail_df.columns]
@@ -678,9 +678,10 @@ class DataBentoDataPolars(PolarsMixin, DataSource):
                 except Exception as e:
                     logger.warning(f"[DATABENTO][MERGE] Failed to merge live tail: {e}")
             
-            # Trim to requested length
+            # Trim to requested length and normalize datetime metadata
             df = df.tail(length)
             df = _ensure_polars_tz(df)
+            df = _ensure_polars_precision(df)
             return Bars(
                 df=df,
                 source=self.SOURCE,

lumibot/entities/asset.py

@@ -702,6 +702,17 @@ class Asset:
             if c not in seen:
                 seen.add(c)
                 unique.append(c)
+
+        # Ensure the resolved primary contract appears first so downstream
+        # consumers try the preferred contract before fallbacks.
+        try:
+            primary = self.resolve_continuous_futures_contract(reference_date)
+        except ValueError:
+            primary = None
+        if primary and primary in unique:
+            unique.remove(primary)
+            unique.insert(0, primary)
+
         return unique
 
     def _determine_continuous_contract_components(

lumibot/strategies/strategy.py

@@ -1830,6 +1830,21 @@ class Strategy(_Strategy):
         >>> self.cancel_open_orders()
 
         """
+        try:
+            tracked_orders = self.broker.get_tracked_orders(self.name)
+            active_orders = [order for order in tracked_orders if order.is_active()]
+            order_ids = [
+                getattr(order, "identifier", None)
+                or getattr(order, "id", None)
+                or getattr(order, "order_id", None)
+                for order in active_orders
+            ]
+            self.log_message(
+                f"cancel_open_orders -> active={len(active_orders)} ids={order_ids}",
+                color="yellow",
+            )
+        except Exception as exc:  # pragma: no cover - defensive logging
+            self.logger.exception("Failed to enumerate open orders before cancellation: %s", exc)
         return self.broker.cancel_open_orders(self.name)
 
     def modify_order(self, order: Order, limit_price: Union[float, None] = None, stop_price: Union[float, None] = None):
@@ -1917,7 +1932,37 @@ class Strategy(_Strategy):
             - If no open position exists, this method does nothing.
         """
         asset_obj = self._sanitize_user_asset(asset)
-        result = self.broker.close_position(self.name, asset_obj, fraction)
+
+        try:
+            position = self.get_position(asset_obj)
+            qty = getattr(position, "quantity", 0) if position else 0
+            self.log_message(
+                f"close_position -> asset={asset_obj.symbol if hasattr(asset_obj, 'symbol') else asset_obj}, "
+                f"fraction={fraction}, current_qty={qty}",
+                color="yellow",
+            )
+        except Exception as exc:  # pragma: no cover - defensive logging
+            self.logger.exception("Unable to inspect position prior to close_position: %s", exc)
+
+        target_asset = getattr(position, "asset", asset_obj) if position is not None else asset_obj
+        if target_asset is not asset_obj:
+            try:
+                self.log_message(
+                    f"close_position -> resolved continuous asset {asset_obj.symbol if hasattr(asset_obj, 'symbol') else asset_obj} "
+                    f"to contract {target_asset.symbol if hasattr(target_asset, 'symbol') else target_asset}",
+                    color="yellow",
+                )
+            except Exception:  # pragma: no cover - best effort logging
+                pass
+        result = self.broker.close_position(self.name, target_asset, fraction)
+        if result is None:
+            self.log_message("close_position -> broker returned None (no order submitted)", color="yellow")
+        else:
+            order_id = getattr(result, "identifier", None) or getattr(result, "id", None) or getattr(result, "order_id", None)
+            self.log_message(
+                f"close_position -> broker submitted order {order_id} (type={type(result).__name__})",
+                color="yellow",
+            )
         if result is not None:
             return result
 

lumibot/tools/databento_helper.py

@@ -784,6 +784,22 @@ def _fetch_and_update_futures_multiplier(
             logger.info(f"[MULTIPLIER] AFTER update: asset.multiplier = {asset.multiplier}")
         else:
             logger.error(f"[MULTIPLIER] ✗ Definition missing unit_of_measure_qty field! Fields: {list(definition.keys())}")
+
+        if (
+            asset.asset_type == Asset.AssetType.FUTURE
+            and getattr(asset, "expiration", None) in (None, "")
+        ):
+            expiration_value = definition.get('expiration')
+            if expiration_value:
+                try:
+                    expiration_ts = pd.to_datetime(expiration_value, utc=True, errors='coerce')
+                except Exception as exc:
+                    logger.debug(f"[MULTIPLIER] Unable to parse expiration '{expiration_value}' for {asset.symbol}: {exc}")
+                    expiration_ts = None
+
+                if expiration_ts is not None and not pd.isna(expiration_ts):
+                    asset.expiration = expiration_ts.date()
+                    logger.debug(f"[MULTIPLIER] ✓ Captured expiration for {asset.symbol}: {asset.expiration}")
     else:
         logger.error(f"[MULTIPLIER] ✗ Failed to get definition from DataBento for {resolved_symbol}")
 

lumibot/tools/databento_helper_polars.py

@@ -863,6 +863,22 @@ def _fetch_and_update_futures_multiplier(
             logger.debug(f"[MULTIPLIER] AFTER update: asset.multiplier = {asset.multiplier}")
         else:
             logger.error(f"[MULTIPLIER] ✗ Definition missing unit_of_measure_qty field! Fields: {list(definition.keys())}")
+
+        if (
+            asset.asset_type == Asset.AssetType.FUTURE
+            and getattr(asset, "expiration", None) in (None, "")
+        ):
+            expiration_value = definition.get('expiration')
+            if expiration_value:
+                try:
+                    expiration_ts = pd.to_datetime(expiration_value, utc=True, errors='coerce')
+                except Exception as exc:
+                    logger.debug(f"[MULTIPLIER] Unable to parse expiration '{expiration_value}' for {asset.symbol}: {exc}")
+                    expiration_ts = None
+
+                if expiration_ts is not None and not pd.isna(expiration_ts):
+                    asset.expiration = expiration_ts.date()
+                    logger.debug(f"[MULTIPLIER] ✓ Captured expiration for {asset.symbol}: {asset.expiration}")
     else:
         logger.error(f"[MULTIPLIER] ✗ Failed to get definition from DataBento for {resolved_symbol}")
 
@@ -1046,8 +1062,10 @@ def get_price_data_from_databento(
                 logger.warning(f"No datetime column found after reset_index, using first column: {first_col}")
                 combined_reset = combined_reset.rename(columns={first_col: 'datetime'})
 
-        # Convert to polars
+        # Convert to polars and normalize datetime metadata
         combined_polars = pl.from_pandas(combined_reset)
+        combined_polars = _ensure_polars_datetime_timezone(combined_polars)
+        combined_polars = _ensure_polars_datetime_precision(combined_polars)
 
         return combined_polars
 
@@ -1239,6 +1257,8 @@ def _generate_databento_symbol_alternatives(base_symbol: str, resolved_contract:
         # Fallback for unexpected contract format - use original contract
         logger.warning(f"Unexpected contract format: {resolved_contract}, using as-is")
         return [resolved_contract]
+
+
 def _ensure_polars_datetime_timezone(df: pl.DataFrame, column: str = "datetime") -> pl.DataFrame:
     """Ensure the specified datetime column is timezone-aware (defaults to UTC)."""
     if column not in df.columns:
@@ -1251,6 +1271,26 @@ def _ensure_polars_datetime_timezone(df: pl.DataFrame, column: str = "datetime")
     return df
 
 
+def _ensure_polars_datetime_precision(
+    df: pl.DataFrame,
+    column: str = "datetime",
+    time_unit: str = "ns",
+) -> pl.DataFrame:
+    """Normalize the precision of a datetime column (default nanosecond)."""
+    if column not in df.columns:
+        return df
+    col_dtype = df.schema.get(column)
+    if not isinstance(col_dtype, pl.Datetime):
+        return df
+    target_dtype = pl.Datetime(
+        time_unit=time_unit,
+        time_zone=col_dtype.time_zone or "UTC",
+    )
+    if col_dtype == target_dtype:
+        return df
+    return df.with_columns(pl.col(column).cast(target_dtype))
+
+
 def get_price_data_from_databento_polars(*args, **kwargs):
     """Compatibility helper that forces polars return type."""
     kwargs.setdefault("return_polars", True)

lumibot/tools/futures_roll.py

@@ -30,13 +30,32 @@ _FUTURES_MONTH_CODES: Dict[int, str] = {
 class RollRule:
     offset_business_days: int
     anchor: str
+    contract_months: Optional[Tuple[int, ...]] = None
+
+
+_DEFAULT_CONTRACT_MONTHS: Tuple[int, ...] = (3, 6, 9, 12)
 
 
 ROLL_RULES: Dict[str, RollRule] = {
-    symbol: RollRule(offset_business_days=8, anchor="third_friday")
+    symbol: RollRule(offset_business_days=8, anchor="third_friday", contract_months=_DEFAULT_CONTRACT_MONTHS)
     for symbol in {"ES", "MES", "NQ", "MNQ", "YM", "MYM"}
 }
 
+ROLL_RULES.update(
+    {
+        "GC": RollRule(
+            offset_business_days=7,
+            anchor="third_last_business_day",
+            contract_months=(2, 4, 6, 8, 10, 12),
+        ),
+        "SI": RollRule(
+            offset_business_days=7,
+            anchor="third_last_business_day",
+            contract_months=(1, 3, 5, 7, 9, 12),
+        ),
+    }
+)
+
 YearMonth = Tuple[int, int]
 
 
@@ -72,9 +91,32 @@ def _subtract_business_days(dt: datetime, days: int) -> datetime:
     return result
 
 
+def _third_last_business_day(year: int, month: int) -> datetime:
+    if month == 12:
+        next_month = 1
+        next_year = year + 1
+    else:
+        next_month = month + 1
+        next_year = year
+
+    last_day = _to_timezone(datetime(next_year, next_month, 1)) - timedelta(days=1)
+
+    remaining = 3
+    cursor = last_day
+    while remaining > 0:
+        if cursor.weekday() < 5:
+            remaining -= 1
+            if remaining == 0:
+                break
+        cursor -= timedelta(days=1)
+    return cursor.replace(hour=0, minute=0, second=0, microsecond=0)
+
+
 def _calculate_roll_trigger(year: int, month: int, rule: RollRule) -> datetime:
     if rule.anchor == "third_friday":
         anchor = _third_friday(year, month)
+    elif rule.anchor == "third_last_business_day":
+        anchor = _third_last_business_day(year, month)
     else:
         anchor = _to_timezone(datetime(year, month, 15))
     if rule.offset_business_days <= 0:
@@ -82,15 +124,28 @@ def _calculate_roll_trigger(year: int, month: int, rule: RollRule) -> datetime:
     return _subtract_business_days(anchor, rule.offset_business_days)
 
 
-def _advance_quarter(current_month: int, current_year: int) -> YearMonth:
-    quarter_months = [3, 6, 9, 12]
-    idx = quarter_months.index(current_month)
-    next_idx = (idx + 1) % len(quarter_months)
-    next_month = quarter_months[next_idx]
-    next_year = current_year + (1 if next_idx == 0 else 0)
+def _get_contract_months(rule: Optional[RollRule]) -> Tuple[int, ...]:
+    if rule and rule.contract_months:
+        return tuple(sorted(rule.contract_months))
+    return _DEFAULT_CONTRACT_MONTHS
+
+
+def _advance_contract(current_month: int, current_year: int, months: Tuple[int, ...]) -> YearMonth:
+    months_sorted = tuple(sorted(months))
+    idx = months_sorted.index(current_month)
+    next_idx = (idx + 1) % len(months_sorted)
+    next_month = months_sorted[next_idx]
+    next_year = current_year + (1 if next_idx <= idx else 0)
     return next_year, next_month
 
 
+def _select_contract(year: int, month: int, months: Tuple[int, ...]) -> YearMonth:
+    for candidate in sorted(months):
+        if month <= candidate:
+            return year, candidate
+    return year + 1, sorted(months)[0]
+
+
 def _legacy_mid_month(reference_date: datetime) -> YearMonth:
     quarter_months = [3, 6, 9, 12]
     year = reference_date.year
@@ -118,27 +173,22 @@ def determine_contract_year_month(symbol: str, reference_date: Optional[datetime
     ref = _normalize_reference_date(reference_date)
     symbol_upper = symbol.upper()
     rule = ROLL_RULES.get(symbol_upper)
-
-    quarter_months = [3, 6, 9, 12]
     year = ref.year
     month = ref.month
 
     if rule is None:
         return _legacy_mid_month(ref)
 
-    if month in quarter_months:
+    contract_months = _get_contract_months(rule)
+
+    if month in contract_months:
         target_year, target_month = year, month
-        roll_point = _calculate_roll_trigger(target_year, target_month, rule)
-        if ref >= roll_point:
-            target_year, target_month = _advance_quarter(target_month, target_year)
     else:
-        candidates = [m for m in quarter_months if m > month]
-        if candidates:
-            target_month = candidates[0]
-            target_year = year
-        else:
-            target_month = quarter_months[0]
-            target_year = year + 1
+        target_year, target_month = _select_contract(year, month, contract_months)
+
+    roll_point = _calculate_roll_trigger(target_year, target_month, rule)
+    if ref >= roll_point:
+        target_year, target_month = _advance_contract(target_month, target_year, contract_months)
 
     return target_year, target_month
 
@@ -201,6 +251,7 @@ def build_roll_schedule(asset, start: datetime, end: datetime, year_digits: int
 
     symbol_upper = asset.symbol.upper()
     rule = ROLL_RULES.get(symbol_upper)
+    contract_months = _get_contract_months(rule)
 
     schedule = []
     cursor = start

lumibot/tools/thetadata_helper.py

@@ -26,6 +26,7 @@ CONNECTION_RETRY_SLEEP = 1.0
 CONNECTION_MAX_RETRIES = 60
 BOOT_GRACE_PERIOD = 5.0
 MAX_RESTART_ATTEMPTS = 3
+MAX_TERMINAL_RESTART_CYCLES = 3
 
 
 def _resolve_asset_folder(asset_obj: Asset) -> str:
@@ -43,6 +44,12 @@ THETA_DATA_PROCESS = None
 THETA_DATA_PID = None
 THETA_DATA_LOG_HANDLE = None
 
+
+class ThetaDataConnectionError(RuntimeError):
+    """Raised when ThetaTerminal cannot reconnect to Theta Data after multiple restarts."""
+
+    pass
+
 def reset_connection_diagnostics():
     """Reset ThetaData connection counters (useful for tests)."""
     CONNECTION_DIAGNOSTICS.update({
@@ -50,6 +57,7 @@ def reset_connection_diagnostics():
         "start_terminal_calls": 0,
         "network_requests": 0,
         "placeholder_writes": 0,
+        "terminal_restarts": 0,
     })
 
 
@@ -198,6 +206,7 @@ CONNECTION_DIAGNOSTICS = {
     "start_terminal_calls": 0,
     "network_requests": 0,
     "placeholder_writes": 0,
+    "terminal_restarts": 0,
 }
 
 
@@ -1395,7 +1404,6 @@ def check_connection(username: str, password: str, wait_for_connection: bool = F
 
     max_retries = CONNECTION_MAX_RETRIES
     sleep_interval = CONNECTION_RETRY_SLEEP
-    restart_attempts = 0
     client = None
 
     def probe_status() -> Optional[str]:
@@ -1435,47 +1443,72 @@ def check_connection(username: str, password: str, wait_for_connection: bool = F
         logger.debug("ThetaTerminal running but not yet CONNECTED; waiting for status.")
         return check_connection(username=username, password=password, wait_for_connection=True)
 
-    counter = 0
-    connected = False
-
-    while counter < max_retries:
-        status_text = probe_status()
-        if status_text == "CONNECTED":
-            if counter:
-                logger.info("ThetaTerminal connected after %s attempt(s).", counter + 1)
-            connected = True
-            break
-        elif status_text == "DISCONNECTED":
-            logger.debug("ThetaTerminal reports DISCONNECTED; will retry.")
-        elif status_text is not None:
-            logger.debug(f"ThetaTerminal returned unexpected status: {status_text}")
-
-        if not is_process_alive():
-            if restart_attempts >= MAX_RESTART_ATTEMPTS:
-                logger.error("ThetaTerminal not running after %s restart attempts.", restart_attempts)
-                break
-            restart_attempts += 1
-            logger.warning("ThetaTerminal process is not running (restart #%s).", restart_attempts)
-            client = start_theta_data_client(username=username, password=password)
-            time.sleep(max(BOOT_GRACE_PERIOD, sleep_interval))
-            counter = 0
-            continue
+    total_restart_cycles = 0
 
-        counter += 1
-        if counter % 10 == 0:
-            logger.info("Waiting for ThetaTerminal connection (attempt %s/%s).", counter, max_retries)
-        time.sleep(sleep_interval)
+    while True:
+        counter = 0
+        restart_attempts = 0
+
+        while counter < max_retries:
+            status_text = probe_status()
+            if status_text == "CONNECTED":
+                if counter or total_restart_cycles:
+                    logger.info(
+                        "ThetaTerminal connected after %s attempt(s) (restart cycles=%s).",
+                        counter + 1,
+                        total_restart_cycles,
+                    )
+                return client, True
+            elif status_text == "DISCONNECTED":
+                logger.debug("ThetaTerminal reports DISCONNECTED; will retry.")
+            elif status_text is not None:
+                logger.debug(f"ThetaTerminal returned unexpected status: {status_text}")
+
+            if not is_process_alive():
+                if restart_attempts >= MAX_RESTART_ATTEMPTS:
+                    logger.error("ThetaTerminal not running after %s restart attempts.", restart_attempts)
+                    break
+                restart_attempts += 1
+                logger.warning("ThetaTerminal process is not running (restart #%s).", restart_attempts)
+                client = start_theta_data_client(username=username, password=password)
+                CONNECTION_DIAGNOSTICS["terminal_restarts"] = CONNECTION_DIAGNOSTICS.get("terminal_restarts", 0) + 1
+                time.sleep(max(BOOT_GRACE_PERIOD, sleep_interval))
+                counter = 0
+                continue
 
-    if not connected and counter >= max_retries:
-        logger.error("Cannot connect to Theta Data after %s attempts.", counter)
+            counter += 1
+            if counter % 10 == 0:
+                logger.info("Waiting for ThetaTerminal connection (attempt %s/%s).", counter, max_retries)
+            time.sleep(sleep_interval)
+
+        total_restart_cycles += 1
+        if total_restart_cycles > MAX_TERMINAL_RESTART_CYCLES:
+            logger.error(
+                "Unable to connect to Theta Data after %s restart cycle(s) (%s attempts each).",
+                MAX_TERMINAL_RESTART_CYCLES,
+                max_retries,
+            )
+            raise ThetaDataConnectionError(
+                f"Unable to connect to Theta Data after {MAX_TERMINAL_RESTART_CYCLES} restart cycle(s)."
+            )
 
-    return client, connected
+        logger.warning(
+            "ThetaTerminal still disconnected after %s attempts; restarting (cycle %s/%s).",
+            max_retries,
+            total_restart_cycles,
+            MAX_TERMINAL_RESTART_CYCLES,
+        )
+        client = start_theta_data_client(username=username, password=password)
+        CONNECTION_DIAGNOSTICS["terminal_restarts"] = CONNECTION_DIAGNOSTICS.get("terminal_restarts", 0) + 1
+        time.sleep(max(BOOT_GRACE_PERIOD, sleep_interval))
 
 
 def get_request(url: str, headers: dict, querystring: dict, username: str, password: str):
     all_responses = []
     next_page_url = None
     page_count = 0
+    consecutive_disconnects = 0
+    restart_budget = 3
 
     # Lightweight liveness probe before issuing the request
     check_connection(username=username, password=password, wait_for_connection=False)
@@ -1498,25 +1531,52 @@ def get_request(url: str, headers: dict, querystring: dict, username: str, passw
                 )
 
                 response = requests.get(request_url, headers=headers, params=request_params)
+                status_code = response.status_code
                 # Status code 472 means "No data" - this is valid, return None
-                if response.status_code == 472:
+                if status_code == 472:
                     logger.warning(f"No data available for request: {response.text[:200]}")
                     # DEBUG-LOG: API response - no data
                     logger.debug(
                         "[THETA][DEBUG][API][RESPONSE] status=472 result=NO_DATA"
                     )
+                    consecutive_disconnects = 0
                     return None
+                elif status_code == 474:
+                    consecutive_disconnects += 1
+                    logger.warning("Received 474 from Theta Data (attempt %s): %s", counter + 1, response.text[:200])
+                    if consecutive_disconnects >= 2:
+                        if restart_budget <= 0:
+                            logger.error("Restart budget exhausted after repeated 474 responses.")
+                            raise ValueError("Cannot connect to Theta Data!")
+                        logger.warning(
+                            "Restarting ThetaTerminal after %s consecutive 474 responses (restart budget remaining %s).",
+                            consecutive_disconnects,
+                            restart_budget - 1,
+                        )
+                        restart_budget -= 1
+                        start_theta_data_client(username=username, password=password)
+                        CONNECTION_DIAGNOSTICS["terminal_restarts"] = CONNECTION_DIAGNOSTICS.get("terminal_restarts", 0) + 1
+                        check_connection(username=username, password=password, wait_for_connection=True)
+                        time.sleep(max(BOOT_GRACE_PERIOD, CONNECTION_RETRY_SLEEP))
+                        consecutive_disconnects = 0
+                        counter = 0
+                    else:
+                        check_connection(username=username, password=password, wait_for_connection=True)
+                        time.sleep(CONNECTION_RETRY_SLEEP)
+                    continue
                 # If status code is not 200, then we are not connected
-                elif response.status_code != 200:
-                    logger.warning(f"Non-200 status code {response.status_code}: {response.text[:200]}")
+                elif status_code != 200:
+                    logger.warning(f"Non-200 status code {status_code}: {response.text[:200]}")
                     # DEBUG-LOG: API response - error
                     logger.debug(
                         "[THETA][DEBUG][API][RESPONSE] status=%d result=ERROR",
-                        response.status_code
+                        status_code
                     )
                     check_connection(username=username, password=password, wait_for_connection=True)
+                    consecutive_disconnects = 0
                 else:
                     json_resp = response.json()
+                    consecutive_disconnects = 0
 
                     # DEBUG-LOG: API response - success
                     response_rows = len(json_resp.get("response", [])) if isinstance(json_resp.get("response"), list) else 0
@@ -1542,6 +1602,12 @@ def get_request(url: str, headers: dict, querystring: dict, username: str, passw
                     else:
                         break
 
+            except ThetaDataConnectionError as exc:
+                logger.error("Theta Data connection failed after supervised restarts: %s", exc)
+                raise
+            except ValueError:
+                # Preserve deliberate ValueError signals (e.g., ThetaData error_type responses)
+                raise
             except Exception as e:
                 logger.warning(f"Exception during request (attempt {counter + 1}): {e}")
                 check_connection(username=username, password=password, wait_for_connection=True)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lumibot
-Version: 4.2.7
+Version: 4.2.10
 Summary: Backtesting and Trading Library, Made by Lumiwealth
 Home-page: https://github.com/Lumiwealth/lumibot
 Author: Robert Grzesik