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

lumibot/data_sources/pandas_data.py

@@ -103,8 +103,8 @@ class PandasData(DataSourceBacktesting):
         df = pd.DataFrame(range(len(dt_index)), index=dt_index)
         df = df.sort_index()
 
-        # Create a column for the date portion only
-        df["dates"] = df.index.date
+        # Create a column for the date portion only (normalize to date, keeping as datetime64 type)
+        df["dates"] = df.index.normalize()
 
         # Merge with the trading calendar on the 'dates' column to get market open/close times.
         # Use a left join to keep all rows from the original index.
@@ -145,7 +145,8 @@ class PandasData(DataSourceBacktesting):
 
         else:
             pcal.columns = ["datetime"]
-            pcal["date"] = pcal["datetime"].dt.date
+            # Normalize to date but keep as datetime64 type (not date objects)
+            pcal["date"] = pcal["datetime"].dt.normalize()
             result = pcal.groupby("date").agg(
                 market_open=(
                     "datetime",
@@ -290,6 +291,8 @@ class PandasData(DataSourceBacktesting):
                 ask=ohlcv_bid_ask_dict.get('ask'),
                 volume=ohlcv_bid_ask_dict.get('volume'),
                 timestamp=dt,
+                bid_size=ohlcv_bid_ask_dict.get('bid_size'),
+                ask_size=ohlcv_bid_ask_dict.get('ask_size'),
                 raw_data=ohlcv_bid_ask_dict
             )
         else:

lumibot/data_sources/polars_mixin.py

@@ -72,17 +72,19 @@ class PolarsMixin:
 
     def _get_data_lazy(self, asset: Asset) -> Optional[pl.LazyFrame]:
         """Get lazy frame for asset.
-        
+
         Parameters
         ----------
-        asset : Asset
-            The asset to get data for
-            
+        asset : Asset or tuple
+            The asset to get data for (can be a tuple of (asset, quote))
+
         Returns
         -------
         Optional[pl.LazyFrame]
             The lazy frame or None if not found
         """
+        # CRITICAL FIX: Handle both Asset and (Asset, quote) tuple keys
+        # The data store uses tuple keys (asset, quote), so we need to look up by that key
         return self._data_store.get(asset)
 
     def _parse_source_symbol_bars_polars(
@@ -95,7 +97,7 @@ class PolarsMixin:
         return_polars: bool = False
     ) -> Bars:
         """Parse bars from polars DataFrame.
-        
+
         Parameters
         ----------
         response : pl.DataFrame
@@ -108,7 +110,7 @@ class PolarsMixin:
             The quote asset for forex/crypto
         length : Optional[int]
             Limit the number of bars
-            
+
         Returns
         -------
         Bars
@@ -121,6 +123,21 @@ class PolarsMixin:
         if length and len(response) > length:
             response = response.tail(length)
 
+        # Filter to only keep OHLCV + datetime columns (remove DataBento metadata like rtype, publisher_id, etc.)
+        # Required columns for strategies
+        required_cols = ['open', 'high', 'low', 'close', 'volume']
+        optional_cols = ['datetime', 'timestamp', 'date', 'time', 'dividend', 'stock_splits', 'symbol']
+
+        # Determine which columns to keep
+        keep_cols = []
+        for col in response.columns:
+            if col in required_cols or col in optional_cols:
+                keep_cols.append(col)
+
+        # Select only the relevant columns
+        if keep_cols:
+            response = response.select(keep_cols)
+
         # Create bars object
         bars = Bars(response, source, asset, raw=response, quote=quote, return_polars=return_polars)
         return bars
@@ -209,22 +226,45 @@ class PolarsMixin:
         self._last_price_cache[cache_key] = price
 
     def _convert_datetime_for_filtering(self, dt: Any) -> datetime:
-        """Convert datetime to naive datetime for filtering.
-        
+        """Convert datetime to naive UTC datetime for filtering.
+
+        CRITICAL FIX: Must convert to UTC BEFORE stripping timezone!
+        If we strip timezone from ET datetime, we lose 5 hours of data.
+
+        Example:
+        - Input: 2024-01-02 18:00:00-05:00 (ET)
+        - Convert to UTC: 2024-01-02 23:00:00+00:00
+        - Strip timezone: 2024-01-02 23:00:00 (naive UTC)
+
+        OLD BUGGY CODE:
+        - Input: 2024-01-02 18:00:00-05:00 (ET)
+        - Strip timezone: 2024-01-02 18:00:00 (naive, loses timezone!)
+        - Compare to cached data in naive UTC: WRONG by 5 hours!
+
         Parameters
         ----------
         dt : Any
             Datetime-like object
-            
+
         Returns
         -------
         datetime
-            Naive datetime object
+            Naive UTC datetime object
         """
-        if hasattr(dt, 'tz_localize'):
-            return dt.tz_localize(None)
+        from datetime import timezone
+
+        # First convert to UTC if timezone-aware
+        if hasattr(dt, 'tzinfo') and dt.tzinfo is not None:
+            # Convert to UTC
+            dt_utc = dt.astimezone(timezone.utc)
+            # Then strip timezone
+            return dt_utc.replace(tzinfo=None)
+        elif hasattr(dt, 'tz_localize'):
+            # Pandas Timestamp
+            return dt.tz_convert('UTC').tz_localize(None)
         elif hasattr(dt, 'replace'):
-            return dt.replace(tzinfo=None)
+            # Already naive
+            return dt
         else:
             return dt
 
@@ -283,10 +323,11 @@ class PolarsMixin:
         lazy_data: pl.LazyFrame,
         end_filter: datetime,
         length: int,
-        timestep: str = "minute"
+        timestep: str = "minute",
+        use_strict_less_than: bool = False
     ) -> Optional[pl.DataFrame]:
         """Filter data up to end_filter and return last length rows.
-        
+
         Parameters
         ----------
         asset : Asset
@@ -299,15 +340,23 @@ class PolarsMixin:
             Number of rows to return
         timestep : str
             Timestep for caching strategy
-            
+        use_strict_less_than : bool
+            If True, use < instead of <= for filtering (matches Pandas behavior without timeshift)
+
         Returns
         -------
         Optional[pl.DataFrame]
             Filtered dataframe or None
         """
+        # DEBUG
+        logger.debug(f"[POLARS FILTER] end_filter={end_filter}, tzinfo={end_filter.tzinfo if hasattr(end_filter, 'tzinfo') else 'N/A'}, length={length}")
+
         # Convert end_filter to naive
         end_filter_naive = self._convert_datetime_for_filtering(end_filter)
 
+        # DEBUG
+        logger.debug(f"[POLARS FILTER] end_filter_naive={end_filter_naive}")
+
         # For daily timestep, use caching
         if timestep == "day":
             current_date = end_filter.date() if hasattr(end_filter, 'date') else end_filter
@@ -335,11 +384,37 @@ class PolarsMixin:
                 return None
 
             # Filter and collect
+            # CRITICAL FIX: Keep timezone info! Match the DataFrame's timezone
+            # Get the DataFrame column's timezone from schema
+            dt_dtype = schema[dt_col]
+
+            # Convert filter to match DataFrame's timezone
+            if hasattr(dt_dtype, 'time_zone') and dt_dtype.time_zone:
+                # DataFrame has timezone, convert filter to match
+                import pytz
+                df_tz = pytz.timezone(dt_dtype.time_zone)
+                end_filter_with_tz = pytz.utc.localize(end_filter_naive).astimezone(df_tz)
+            else:
+                # DataFrame is naive, use UTC
+                from datetime import timezone as tz
+                end_filter_with_tz = datetime.combine(
+                    end_filter_naive.date(),
+                    end_filter_naive.time(),
+                    tzinfo=tz.utc
+                )
+
+            # CRITICAL FIX: Deduplicate before caching
+            # Use < or <= based on use_strict_less_than flag
+            if use_strict_less_than:
+                filter_expr = pl.col(dt_col) < end_filter_with_tz
+            else:
+                filter_expr = pl.col(dt_col) <= end_filter_with_tz
+
             result = (
                 lazy_data
-                .with_columns(pl.col(dt_col).cast(pl.Datetime("us")))
-                .filter(pl.col(dt_col) <= end_filter_naive)
+                .filter(filter_expr)
                 .sort(dt_col)
+                .unique(subset=[dt_col], keep='last', maintain_order=True)
                 .tail(fetch_length)
                 .collect()
             )
@@ -362,11 +437,41 @@ class PolarsMixin:
                 logger.error("No datetime column found")
                 return None
 
-            return (
+            # CRITICAL FIX: Keep timezone info during filtering!
+            # Match the DataFrame's timezone to avoid comparison errors
+            # Get the DataFrame column's timezone from schema
+            dt_dtype = schema[dt_col]
+
+            # Convert filter to match DataFrame's timezone
+            if hasattr(dt_dtype, 'time_zone') and dt_dtype.time_zone:
+                # DataFrame has timezone, convert filter to match
+                import pytz
+                df_tz = pytz.timezone(dt_dtype.time_zone)
+                end_filter_with_tz = pytz.utc.localize(end_filter_naive).astimezone(df_tz)
+            else:
+                # DataFrame is naive, use UTC
+                from datetime import timezone as tz
+                end_filter_with_tz = datetime.combine(
+                    end_filter_naive.date(),
+                    end_filter_naive.time(),
+                    tzinfo=tz.utc
+                )
+
+            # CRITICAL FIX: Deduplicate before returning
+            # Sometimes lazy operations can create duplicates
+            # Use < or <= based on use_strict_less_than flag
+            if use_strict_less_than:
+                filter_expr = pl.col(dt_col) < end_filter_with_tz
+            else:
+                filter_expr = pl.col(dt_col) <= end_filter_with_tz
+
+            result = (
                 lazy_data
-                .with_columns(pl.col(dt_col).cast(pl.Datetime("us")))
-                .filter(pl.col(dt_col) <= end_filter_naive)
+                .filter(filter_expr)
                 .sort(dt_col)
+                .unique(subset=[dt_col], keep='last', maintain_order=True)
                 .tail(length)
                 .collect()
             )
+
+            return result

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,