quantex 0.4.7__tar.gz → 0.4.8__tar.gz

{quantex-0.4.7 → quantex-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: quantex
-Version: 0.4.7
+Version: 0.4.8
 Summary: A simple quant strategy creation and backtesting package.
 License: MIT
 Author: Daniel Green

{quantex-0.4.7 → quantex-0.4.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "quantex"
-version = "0.4.7"
+version = "0.4.8"
 description = "A simple quant strategy creation and backtesting package."
 authors = [
     {name = "Daniel Green",email = "dangreen07@outlook.com"}

{quantex-0.4.7 → quantex-0.4.8}/src/quantex/backtester/backtester.py

@@ -38,6 +38,7 @@ class SimpleBacktester:
     - Position management
     - Margin calls
     - P&L tracking
+    - Leverage for amplified position sizing
     
     Example:
         >>> from quantex import SimpleBacktester, CSVDataSource  
@@ -54,7 +55,8 @@ class SimpleBacktester:
                 commission: float = 0.002, 
                 commission_type: CommissionType = CommissionType.PERCENTAGE,
                 lot_size: int = 1,
-                margin_call: float = 0.5  ## 50% of the cash lost
+                margin_call: float = 0.5,  ## 50% of the cash lost
+                leverage: float = 1.0  ## Leverage multiplier (1.0 = no leverage)
                 ):
         """
         Initialize the backtester with strategy and configuration parameters.
@@ -70,16 +72,25 @@ class SimpleBacktester:
             lot_size (int, optional): Size of trading lots. Defaults to 1.
             margin_call (float, optional): Margin call threshold as fraction of
                 cash value. Defaults to 0.5 (50%).
+            leverage (float, optional): Leverage multiplier for position sizing.
+                Defaults to 1.0 (no leverage). For example:
+                - 2.0 = 2x leverage (control 2x the position with same cash)
+                - 0.5 = half leverage (control half the position)
                 
         Raises:
             ValueError: If strategy is None or commission rate is negative.
         """
+        if leverage < 0.1:
+            raise ValueError("leverage must be at least 0.1")
+        if leverage > 100:
+            raise ValueError("leverage cannot exceed 100")
         self.strategy = copy.deepcopy(strategy)
         self.cash = cash
         self.commission = commission
         self.commission_type = commission_type
         self.lot_size = lot_size
         self.margin_call = margin_call
+        self.leverage = leverage
         source = self.strategy.positions[list(self.strategy.positions.keys())[0]].source
         self.PnLRecord = np.zeros(len(source.data['Close']), dtype=np.float64)
 
@@ -140,6 +151,7 @@ class SimpleBacktester:
             broker.cash = per_position_cash
             broker.lot_size = self.lot_size
             broker.margin_call = self.margin_call
+            broker.leverage = self.leverage
             broker.commision = np.float64(self.commission)
             broker.commision_type = self.commission_type
 
@@ -302,6 +314,7 @@ class SimpleBacktester:
                 commission=self.commission,
                 commission_type=self.commission_type,
                 lot_size=self.lot_size,
+                leverage=self.leverage,
             )
             report = bt.run(progress_bar=False)
 
@@ -504,6 +517,7 @@ class SimpleBacktester:
                 self.commission,
                 self.commission_type,
                 self.lot_size,
+                self.leverage,
             ),
         ) as exe:
             # map the worker over param item tuples
@@ -561,6 +575,7 @@ class SimpleBacktester:
             commission=self.commission,
             commission_type=self.commission_type,
             lot_size=self.lot_size,
+            leverage=self.leverage,
         )
         best_report = bt.run(progress_bar=False)
 
@@ -679,6 +694,7 @@ class SimpleBacktester:
             commission: float,
             commission_type: CommissionType,
             lot_size: int,
+            leverage: float,
             objective: str,
             risk_tolerance: dict[str, float] | None,
             constraint: Callable[[dict[str, Any]], bool] | None,
@@ -750,6 +766,7 @@ class SimpleBacktester:
                     commission=commission,
                     commission_type=commission_type,
                     lot_size=lot_size,
+                    leverage=leverage,
                 )
                 report = bt.run(progress_bar=False)
                 
@@ -790,6 +807,7 @@ class SimpleBacktester:
             commission=self.commission,
             commission_type=self.commission_type,
             lot_size=self.lot_size,
+            leverage=self.leverage,
             objective=objective,
             risk_tolerance=risk_tolerance,
             constraint=constraint,
@@ -843,6 +861,7 @@ class SimpleBacktester:
             commission=self.commission,
             commission_type=self.commission_type,
             lot_size=self.lot_size,
+            leverage=self.leverage,
         )
         best_report = bt.run(progress_bar=False)
         best_metrics = _compute_backtest_metrics(best_report)
@@ -1024,6 +1043,7 @@ class SimpleBacktester:
                     commission=self.commission,
                     commission_type=self.commission_type,
                     lot_size=self.lot_size,
+                    leverage=self.leverage,
                 )
                 report = bt.run(progress_bar=False)
                 metrics = _compute_backtest_metrics(report)
@@ -1086,7 +1106,7 @@ class SimpleBacktester:
             best_params = {}
             best_validate_score = -np.inf
         
-        # Get full reports for best parameters
+            # Get full reports for best parameters
         train_report = None
         validate_report = None
         test_report = None
@@ -1108,6 +1128,7 @@ class SimpleBacktester:
                     commission=self.commission,
                     commission_type=self.commission_type,
                     lot_size=self.lot_size,
+                    leverage=self.leverage,
                 )
                 report = bt.run(progress_bar=False)
                 metrics = _compute_backtest_metrics(report)
@@ -1302,6 +1323,7 @@ class SimpleBacktester:
                 commission=self.commission,
                 commission_type=self.commission_type,
                 lot_size=self.lot_size,
+                leverage=self.leverage,
             )
             report = bt.run(progress_bar=False)
             metrics = _compute_backtest_metrics(report)
@@ -1425,6 +1447,7 @@ class SimpleBacktester:
                 commission=self.commission,
                 commission_type=self.commission_type,
                 lot_size=self.lot_size,
+                leverage=self.leverage,
             )
             report = bt.run(progress_bar=False)
             metrics = _compute_backtest_metrics(report)

{quantex-0.4.7 → quantex-0.4.8}/src/quantex/backtester/montecarlo.py

@@ -462,6 +462,7 @@ def _run_price_path_simulation(
     commission: float,
     commission_type,
     lot_size: int,
+    leverage: float = 1.0,
     seed: int | None = None,
 ) -> pd.Series:
     """
@@ -477,6 +478,7 @@ def _run_price_path_simulation(
         commission (float): Commission rate.
         commission_type: Commission type enum.
         lot_size (int): Lot size for trading.
+        leverage (float): Leverage multiplier for position sizing.
         seed (int | None): Random seed for reproducibility.
     
     Returns:
@@ -581,6 +583,7 @@ def _run_price_path_simulation(
         commission=commission,
         commission_type=commission_type,
         lot_size=lot_size,
+        leverage=leverage,
     )
     report = bt.run(progress_bar=False)
     
@@ -705,6 +708,7 @@ def monte_carlo(
                 self.commission,
                 self.commission_type,
                 self.lot_size,
+                leverage=self.leverage,
                 seed=iter_seed,
             )
             equity_curves.append(curve)

{quantex-0.4.7 → quantex-0.4.8}/src/quantex/backtester/parallel.py

@@ -20,7 +20,8 @@ def _worker_init(
     cash: float,
     commision: float,
     commision_type: Any,
-    lot_size: int
+    lot_size: int,
+    leverage: float,
 ) -> None:
     """
     Initializer for worker processes in parallel optimization.
@@ -35,6 +36,7 @@ def _worker_init(
         commision (float): Commission rate for trades.
         commision_type: Type of commission calculation (CommissionType enum).
         lot_size (int): Size of trading lots.
+        leverage (float): Leverage multiplier for position sizing.
         
     Note:
         This function is designed to be called by worker processes
@@ -47,6 +49,7 @@ def _worker_init(
         "commision": commision,
         "commision_type": commision_type,
         "lot_size": lot_size,
+        "leverage": leverage,
     }
 
 
@@ -176,6 +179,7 @@ def _worker_eval(param_items: tuple[tuple[str, Any], ...]) -> dict[str, Any]:
         commission=config["commision"],
         commission_type=config["commision_type"],
         lot_size=config["lot_size"],
+        leverage=config["leverage"],
     )
     report = bt.run(progress_bar=False)
 

{quantex-0.4.7 → quantex-0.4.8}/src/quantex/broker/broker.py

@@ -52,6 +52,7 @@ class Broker:
     - Commission calculations
     - Stop loss and take profit order management
     - P&L record tracking
+    - Leverage for amplified position sizing
     
     Example:
         >>> source = CSVDataSource("data.csv")  
@@ -74,6 +75,7 @@ class Broker:
         self.commision_type: CommissionType = CommissionType.PERCENTAGE
         self.lot_size: int = 1
         self.margin_call: float = 0.5 ## 50% of the cash value
+        self.leverage: float = 1.0  ## Leverage multiplier (1.0 = no leverage)
         self.share_decimals = 1
         self.orders: list[Order] = []
         self.complete_orders = []
@@ -154,7 +156,9 @@ class Broker:
               during the next iteration.
             - Market orders execute immediately at current open price.
             - Limit orders only execute when price reaches the specified level.
-              
+            - Leverage amplifies position size - with 2x leverage and quantity=1,
+              you control 2x the shares while only using 1x cash as margin.
+               
         Example:
             >>> broker = Broker(source)  
             >>> # Buy with 25% of available cash  
@@ -176,9 +180,15 @@ class Broker:
         else:
             type = OrderType.MARKET
         current_price = self.source.Close[-1]
-        total_shares = round((self.cash * quantity) / current_price, self.share_decimals)
         if (amount):
+            # When using absolute amount, still apply leverage to the base calculation
+            # but the user-provided amount is the final leveraged position size
             total_shares = amount
+        else:
+            # Calculate shares: base on cash * quantity, then apply leverage
+            base_shares = round((self.cash * quantity) / current_price, self.share_decimals)
+            # Apply leverage to increase position size
+            total_shares = round(base_shares * self.leverage, self.share_decimals)
         order = Order(
             side=OrderSide.BUY, 
             quantity=total_shares, 
@@ -489,7 +499,9 @@ class Broker:
                                         self.position_avg_price = (old_pos * self.position_avg_price + order.quantity * order.price) / new_pos
                                 else:
                                     self.position_avg_price = order.price
-                                self._debit(order.price * order.quantity)
+                                # Calculate margin (cash used) for leveraged positions
+                                margin = order.price * order.quantity / self.leverage
+                                self._debit(margin)
                                 self._apply_commission(order.quantity, order.price)
                                 self.position = new_pos
                         else:
@@ -504,7 +516,9 @@ class Broker:
                                         self.position_avg_price = (old_pos * self.position_avg_price + order.quantity * order.price) / new_pos
                                 else:
                                     self.position_avg_price = order.price
-                                self._credit(order.price * order.quantity)
+                                # Calculate margin released for leveraged positions
+                                margin = order.price * order.quantity / self.leverage
+                                self._credit(margin)
                                 self._apply_commission(order.quantity, order.price)
                                 self.position = new_pos
                         if (order.stop_loss or order.take_profit):
@@ -526,7 +540,9 @@ class Broker:
                                         self.position_avg_price = (old_pos * self.position_avg_price + order.quantity * price) / new_pos
                                 else:
                                     self.position_avg_price = price
-                                self._debit(self.source.COpen * order.quantity)
+                                # Calculate margin (cash used) for leveraged positions
+                                margin = self.source.COpen * order.quantity / self.leverage
+                                self._debit(margin)
                                 self._apply_commission(order.quantity, self.source.COpen)
                                 self.position = new_pos
                             else:
@@ -540,7 +556,9 @@ class Broker:
                                         self.position_avg_price = (old_pos * self.position_avg_price + order.quantity * price) / new_pos
                                 else:
                                     self.position_avg_price = price
-                                self._credit(self.source.COpen * order.quantity)
+                                # Calculate margin released for leveraged positions
+                                margin = self.source.COpen * order.quantity / self.leverage
+                                self._credit(margin)
                                 self._apply_commission(order.quantity, self.source.COpen)
                                 self.position = new_pos
                             if (order.stop_loss or order.take_profit):
@@ -604,13 +622,15 @@ class Broker:
                 self.pending_close_order = None
         unrealized = self.position * self.source.CClose
         equity = self.cash + unrealized
-        margin_call = self.margin_call * abs(self.position) * self.source.CClose
-        if equity < margin_call and self.position < 0:
+        # Calculate actual margin used, accounting for leverage
+        actual_margin = abs(self.position) * self.source.CClose / self.leverage
+        margin_call_threshold = self.margin_call * actual_margin
+        if equity < margin_call_threshold and self.position < 0:
             self.margin_call_triggered = True
             self.margin_call_events.append({
                 "timestamp": self.source.Index[self._i],
                 "equity": equity,
-                "margin_call_threshold": margin_call,
+                "margin_call_threshold": margin_call_threshold,
                 "position": self.position,
             })
             self.close() ## Close all positions immediately, margin call

{quantex-0.4.7 → quantex-0.4.8}/src/quantex/strategy.py

@@ -119,7 +119,9 @@ class Strategy(ABC):
             >>> class MyStrategy(Strategy):  
             ...     def init(self):  
             ...         self.add_data(CSVDataSource("AAPL.csv"), "AAPL")  
-            ...         self.add_data(CSVDataSource("EURUSD.csv"), "EURUSD")  
+            ...     def next(self):  
+            ...         if self.data['AAPL'].CClose > self.data['AAPL'].Close[-1]:  
+            ...             self.positions['AAPL'].buy(quantity=0.1)  
         """
         self.data[symbol] = source
         self.positions[symbol] = Broker(source)