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

lumibot/data_sources/tradeovate_data.py

@@ -0,0 +1,80 @@
+import logging
+from decimal import Decimal
+from typing import Union
+
+from termcolor import colored
+from lumibot.entities import Asset, Bars
+from lumibot.data_sources import DataSource
+
+class TradeovateData(DataSource):
+    """
+    Data source that connects to the Tradovate Market Data API.
+    Note: Tradovate market data is delivered via WebSocket.
+    """
+    MIN_TIMESTEP = "minute"
+    SOURCE = "Tradeovate"
+
+    def __init__(self, config, trading_token=None, market_token=None):
+        super().__init__()
+        self.config = config
+        # Use the market data WebSocket URL from config or default.
+        self.ws_url = config.get("MD_WS_URL", "wss://md.tradovateapi.com/v1/websocket")
+        # REST endpoint for market data.
+        self.market_data_url = config.get("MD_URL", "https://md.tradovateapi.com/v1")
+        # Store tokens directly
+        self.trading_token = trading_token
+        self.market_token = market_token
+        # Trading API URL for contract lookup
+        self.trading_api_url = config.get("TRADING_API_URL", "https://demo.tradovateapi.com/v1")
+
+    def _get_headers(self, with_auth=True, with_content_type=False):
+        """
+        Create headers for API requests.
+        
+        Parameters
+        ----------
+        with_auth : bool
+            Whether to include the Authorization header with the trading token
+        with_content_type : bool
+            Whether to include Content-Type header for JSON requests
+            
+        Returns
+        -------
+        dict
+            Dictionary of headers for API requests
+        """
+        headers = {"Accept": "application/json"}
+        if with_auth and self.trading_token:
+            headers["Authorization"] = f"Bearer {self.trading_token}"
+        if with_content_type:
+            headers["Content-Type"] = "application/json"
+        return headers
+
+    def get_chains(self, asset: Asset, quote: Asset = None) -> dict:
+        logging.error(colored("Method 'get_chains' does not work with Tradovate.", "red"))
+        return {}
+
+    def get_historical_prices(
+        self, asset, length, timestep="", timeshift=None, quote=None, exchange=None, include_after_hours=True
+    ) -> Bars:
+        """
+        Retrieve historical chart data for the given asset via WebSocket using the md/getChart command.
+        This method sends a WebSocket request to retrieve 'length' bars of historical data.
+        
+        Note: Tradovate provides historical chart data via WebSocket, not via a REST GET.
+        """
+
+        # Log that this method is not supported because Tradovate requires you to get a CME subscription which costs $440/month
+        logging.error(colored("Method 'get_historical_prices' is not implemented for Tradovate because it requires a CME subscription which costs $440/month.", "red"))
+        return None
+
+    def get_last_price(self, asset, quote=None, exchange=None) -> Union[float, Decimal, None]:
+        """
+        Retrieve the most recent price for the given asset via WebSocket.
+        This method first retrieves the contract ID for the asset's symbol, then subscribes
+        to market data using that contract ID.
+        """
+       
+        # Log that this method is not supported because Tradovate requires you to get a CME subscription which costs $440/month
+        logging.error(colored("Method 'get_last_price' is not implemented for Tradovate because it requires a CME subscription which costs $440/month.", "red"))
+        return None

lumibot/data_sources/tradier_data.py

@@ -255,7 +255,8 @@ class TradierData(DataSource):
             days_needed = length
         else:
             # For minute bars, calculate additional days needed accounting for weekends/holidays
-            minutes_per_day = 390  # ~6.5 hours of trading per day
+            # minutes_per_day = 390  # ~6.5 hours of trading per day
+            minutes_per_day = 24 * 60 / timestep_qty  # Need to include premarket and after hours
             days_needed = (length // minutes_per_day) + 1
 
         start_date = date_n_trading_days_from_date(

lumibot/entities/asset.py

@@ -249,6 +249,10 @@ class Asset:
         if asset_type == self.AssetType.OPTION:
             self.multiplier = 100
 
+        # Note: Futures multipliers should be fetched from data provider (e.g., DataBento)
+        # at the data source level, not hardcoded here. The Asset class accepts multiplier
+        # as a parameter if the data source provides it.
+
         # Make sure right is upper case
         if right is not None:
             self.right = right.upper()
@@ -707,6 +711,10 @@ class Asset:
         if reference_date is None:
             reference_date = datetime.now()
 
+        # import logging
+        # logger = logging.getLogger(__name__)
+        # logger.info(f"[CONTRACT RESOLUTION] symbol={self.symbol}, reference_date={reference_date}, month={reference_date.month}, day={reference_date.day}")
+
         current_month = reference_date.month
         current_year = reference_date.year
         current_day = reference_date.day

lumibot/entities/order.py

@@ -1108,7 +1108,7 @@ class Order:
         if self.asset is None:
             logger.error(f"Cannot create position from order {self.identifier} - asset is None")
             return None
-            
+
         position_qty = quantity
         if self.side == SELL:
             position_qty = -quantity

lumibot/entities/quote.py

@@ -83,6 +83,20 @@ class Quote:
             return (self.bid + self.ask) / 2
         return self.price
 
+    def __getitem__(self, key):
+        """
+        Allow dictionary-style access to Quote attributes for backward compatibility.
+        Tries to get the attribute first, then falls back to raw_data if available.
+        """
+        # Try to get as an attribute first
+        if hasattr(self, key):
+            return getattr(self, key)
+        # Fall back to raw_data if it exists
+        elif self.raw_data and key in self.raw_data:
+            return self.raw_data[key]
+        else:
+            raise KeyError(f"'{key}' not found in Quote object or raw_data")
+
     def __str__(self):
         return (f"Quote(asset={self.asset}, price={self.price}, bid={self.bid}, ask={self.ask}, "
                 f"volume={self.volume}, timestamp={self.timestamp})")

lumibot/strategies/_strategy.py

@@ -684,6 +684,7 @@ class _Strategy:
 
             positions = self.broker.get_tracked_positions(self._name)
             assets_original = [position.asset for position in positions]
+
             # Set the base currency for crypto valuations.
 
             prices = {}
@@ -752,8 +753,33 @@ class _Strategy:
                 if isinstance(asset, tuple):
                     multiplier = 1
                 else:
-                    multiplier = asset.multiplier if asset.asset_type in ["option", "future"] else 1
-                portfolio_value += float(quantity) * float(price) * multiplier
+                    multiplier = asset.multiplier if asset.asset_type in ["option", "future", "cont_future"] else 1
+
+                # BACKTESTING ONLY: Special handling for futures portfolio value
+                # In backtesting, cash has margin deducted, so we need to add it back
+                # In live trading, brokers handle this internally
+                if (
+                    self.is_backtesting
+                    and not isinstance(asset, tuple)
+                    and asset.asset_type in ["future", "cont_future"]
+                ):
+                    # Import here to avoid circular dependency
+                    from lumibot.backtesting.backtesting_broker import get_futures_margin_requirement
+
+                    # Add margin tied up in position (was deducted from cash)
+                    margin_per_contract = get_futures_margin_requirement(asset)
+                    total_margin = margin_per_contract * abs(float(quantity))
+                    portfolio_value += total_margin
+
+                    # Add unrealized P&L = (current_price - entry_price) × quantity × multiplier
+                    entry_price = position.avg_fill_price if (hasattr(position, 'avg_fill_price') and position.avg_fill_price) else price
+                    unrealized_pnl = (float(price) - float(entry_price)) * float(quantity) * multiplier
+                    portfolio_value += unrealized_pnl
+                else:
+                    # All other cases (stocks, options, crypto, live trading)
+                    position_value = float(quantity) * float(price) * multiplier
+                    portfolio_value += position_value
+
             self._portfolio_value = portfolio_value
         return portfolio_value
 
@@ -1238,6 +1264,63 @@ class _Strategy:
         if show_indicators is None:
             show_indicators = SHOW_INDICATORS
 
+        # Auto-select datasource from environment variable if None
+        if datasource_class is None:
+            from lumibot.credentials import BACKTESTING_DATA_SOURCE
+            from lumibot.backtesting import (
+                PolygonDataBacktesting,
+                ThetaDataBacktesting,
+                YahooDataBacktesting,
+                AlpacaBacktesting,
+                CcxtBacktesting,
+                DataBentoDataBacktesting,
+            )
+
+            datasource_map = {
+                "polygon": PolygonDataBacktesting,
+                "thetadata": ThetaDataBacktesting,
+                "yahoo": YahooDataBacktesting,
+                "alpaca": AlpacaBacktesting,
+                "ccxt": CcxtBacktesting,
+                "databento": DataBentoDataBacktesting,
+            }
+
+            datasource_name = BACKTESTING_DATA_SOURCE.lower()
+            if datasource_name not in datasource_map:
+                raise ValueError(
+                    f"Unknown BACKTESTING_DATA_SOURCE: '{BACKTESTING_DATA_SOURCE}'. "
+                    f"Valid options: {list(datasource_map.keys())}"
+                )
+
+            datasource_class = datasource_map[datasource_name]
+            get_logger(__name__).info(colored(
+                f"Auto-selected backtesting data source from BACKTESTING_DATA_SOURCE env var: {BACKTESTING_DATA_SOURCE}",
+                "green"
+            ))
+
+        # Make sure polygon_api_key is set if using PolygonDataBacktesting
+        polygon_api_key = polygon_api_key if polygon_api_key is not None else POLYGON_API_KEY
+        if datasource_class.__name__ == 'PolygonDataBacktesting' and polygon_api_key is None:
+            raise ValueError(
+                "Please set `POLYGON_API_KEY` to your API key from polygon.io as an environment variable if "
+                "you are using PolygonDataBacktesting. If you don't have one, you can get a free API key "
+                "from https://polygon.io/."
+            )
+
+        # Make sure thetadata_username and thetadata_password are set if using ThetaDataBacktesting
+        if thetadata_username is None or thetadata_password is None:
+            # Try getting the Theta Data credentials from credentials
+            thetadata_username = THETADATA_CONFIG.get('THETADATA_USERNAME')
+            thetadata_password = THETADATA_CONFIG.get('THETADATA_PASSWORD')
+
+            # Check again if theta data username and pass are set (before checking dict)
+            if datasource_class.__name__ == 'ThetaDataBacktesting' and (thetadata_username is None or thetadata_password is None):
+                raise ValueError(
+                    "Please set `thetadata_username` and `thetadata_password` in the backtest() function if "
+                    "you are using ThetaDataBacktesting. If you don't have one, you can do registeration "
+                    "from https://www.thetadata.net/."
+                )
+
         # check if datasource_class is a class or a dictionary
         if isinstance(datasource_class, dict):
             optionsource_class = datasource_class["OPTION"]
@@ -1247,6 +1330,14 @@ class _Strategy:
                 use_other_option_source = False
             else:
                 use_other_option_source = True
+
+            # Check ThetaData credentials for optionsource_class after dict extraction
+            if optionsource_class.__name__ == 'ThetaDataBacktesting' and (thetadata_username is None or thetadata_password is None):
+                raise ValueError(
+                    "Please set `thetadata_username` and `thetadata_password` in the backtest() function if "
+                    "you are using ThetaDataBacktesting. If you don't have one, you can do registeration "
+                    "from https://www.thetadata.net/."
+                )
         else:
             optionsource_class = None
             use_other_option_source = False
@@ -1277,29 +1368,6 @@ class _Strategy:
 
         self.verify_backtest_inputs(backtesting_start, backtesting_end)
 
-        # Make sure polygon_api_key is set if using PolygonDataBacktesting
-        polygon_api_key = polygon_api_key if polygon_api_key is not None else POLYGON_API_KEY
-        if datasource_class == PolygonDataBacktesting and polygon_api_key is None:
-            raise ValueError(
-                "Please set `POLYGON_API_KEY` to your API key from polygon.io as an environment variable if "
-                "you are using PolygonDataBacktesting. If you don't have one, you can get a free API key "
-                "from https://polygon.io/."
-            )
-
-        # Make sure thetadata_username and thetadata_password are set if using ThetaDataBacktesting
-        if thetadata_username is None or thetadata_password is None:
-            # Try getting the Theta Data credentials from credentials
-            thetadata_username = THETADATA_CONFIG.get('THETADATA_USERNAME')
-            thetadata_password = THETADATA_CONFIG.get('THETADATA_PASSWORD')
-
-            # Check again if theta data username and pass are set
-            if (thetadata_username is None or thetadata_password is None) and (datasource_class == ThetaDataBacktesting or optionsource_class == ThetaDataBacktesting):
-                raise ValueError(
-                    "Please set `thetadata_username` and `thetadata_password` in the backtest() function if "
-                    "you are using ThetaDataBacktesting. If you don't have one, you can do registeration "
-                    "from https://www.thetadata.net/."
-                )
-
         if not self.IS_BACKTESTABLE:
             get_logger(__name__).warning(f"Strategy {name + ' ' if name is not None else ''}cannot be " f"backtested at the moment")
             return None
@@ -1323,7 +1391,7 @@ class _Strategy:
 
         self._trader = trader_class(logfile=logfile, backtest=True, quiet_logs=quiet_logs)
 
-        if datasource_class == PolygonDataBacktesting:
+        if datasource_class.__name__ == 'PolygonDataBacktesting':
             data_source = datasource_class(
                 backtesting_start,
                 backtesting_end,
@@ -1336,7 +1404,7 @@ class _Strategy:
                 log_backtest_progress_to_file=LOG_BACKTEST_PROGRESS_TO_FILE,
                 **kwargs,
             )
-        elif datasource_class == ThetaDataBacktesting or optionsource_class == ThetaDataBacktesting:
+        elif datasource_class.__name__ == 'ThetaDataBacktesting' or (optionsource_class and optionsource_class.__name__ == 'ThetaDataBacktesting'):
             data_source = datasource_class(
                 backtesting_start,
                 backtesting_end,

lumibot/strategies/strategy.py

@@ -374,11 +374,10 @@ class Strategy(_Strategy):
             # Send the message to Discord
             self.send_discord_message(message)
 
-        # If we are backtesting and we don't want to save the logfile, don't log (they're not displayed in the console anyway)
-        if not self.save_logfile and self.is_backtesting:
-            return
-
-        # Check if INFO level is enabled before logging
+        # Performance optimization: skip logging if INFO is not enabled
+        # This respects BACKTESTING_QUIET_LOGS via StrategyLoggerAdapter.isEnabledFor()
+        # When BACKTESTING_QUIET_LOGS=true (default), this returns False and saves CPU cycles
+        # When BACKTESTING_QUIET_LOGS=false, this returns True and logs are displayed
         if not self.logger.isEnabledFor(logging.INFO):
             return
 
@@ -4411,7 +4410,7 @@ class Strategy(_Strategy):
         save_logfile: bool = False,
         thetadata_username: str = None,
         thetadata_password: str = None,
-        use_quote_data: bool = False,
+        use_quote_data: bool = True,  # Changed to True for ThetaData options support
         show_progress_bar: bool = True,
         quiet_logs: bool = True,
         trader_class: Type[Trader] = Trader,

lumibot/strategies/strategy_executor.py

@@ -474,7 +474,7 @@ class StrategyExecutor(Thread):
 
             if (
                 update_cash
-                and asset_type != Asset.AssetType.CRYPTO
+                and asset_type not in (Asset.AssetType.CRYPTO, Asset.AssetType.FUTURE, Asset.AssetType.CONT_FUTURE)
                 and quantity is not None
                 and price is not None
             ):
@@ -509,7 +509,7 @@ class StrategyExecutor(Thread):
 
             if (
                 update_cash
-                and asset_type != Asset.AssetType.CRYPTO
+                and asset_type not in (Asset.AssetType.CRYPTO, Asset.AssetType.FUTURE, Asset.AssetType.CONT_FUTURE)
                 and quantity is not None
                 and price is not None
             ):