bbstrader 0.1.92__tar.gz → 0.1.93__tar.gz

{bbstrader-0.1.92/bbstrader.egg-info → bbstrader-0.1.93}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bbstrader
-Version: 0.1.92
+Version: 0.1.93
 Summary: Simplified Investment & Trading Toolkit
 Home-page: https://github.com/bbalouki/bbstrader
 Download-URL: https://pypi.org/project/bbstrader/

{bbstrader-0.1.92 → bbstrader-0.1.93}/bbstrader/btengine/backtest.py

@@ -85,6 +85,8 @@ class BacktestEngine(Backtest):
             strategy (Strategy): Generates signals based on market data.
             kwargs : Additional parameters based on the `ExecutionHandler`, 
                 the `DataHandler`, the `Strategy` used and the `Portfolio`.
+                - show_equity (bool): Show the equity curve of the portfolio.
+                - stats_file (str): File to save the summary stats.
         """
         self.symbol_list = symbol_list
         self.initial_capital = initial_capital
@@ -104,6 +106,7 @@ class BacktestEngine(Backtest):
 
         self._generate_trading_instances()
         self.show_equity = kwargs.get("show_equity", False)
+        self.stats_file = kwargs.get("stats_file", None)
 
     def _generate_trading_instances(self):
         """
@@ -137,14 +140,21 @@ class BacktestEngine(Backtest):
         i = 0
         while True:
             i += 1
-            # Update the market bars
+            value = self.portfolio.all_holdings[-1]['Total']
             if self.data_handler.continue_backtest == True:
+                # Update the market bars
                 self.data_handler.update_bars()
                 self.strategy.check_pending_orders()
+                self.strategy.get_update_from_portfolio(
+                    self.portfolio.current_positions,
+                    self.portfolio.current_holdings
+                )
+                self.strategy.cash = value
             else:
                 print("\n[======= BACKTEST COMPLETED =======]")
-                print(f"END DATE: {self.data_handler.get_latest_bar_datetime()}")
+                print(f"END DATE: {self.data_handler.get_latest_bar_datetime(self.symbol_list[0])}")
                 print(f"TOTAL BARS: {i} ")
+                print(f"PORFOLIO VALUE: {round(value, 2)}")
                 break
 
             # Handle the events
@@ -171,10 +181,6 @@ class BacktestEngine(Backtest):
                             self.fills += 1
                             self.portfolio.update_fill(event)
                             self.strategy.update_trades_from_fill(event)
-                            self.strategy.get_update_from_portfolio(
-                                self.portfolio.current_positions,
-                                self.portfolio.current_holdings
-                            )
 
             time.sleep(self.heartbeat)
 
@@ -192,13 +198,13 @@ class BacktestEngine(Backtest):
         stat2['Orders'] = self.orders
         stat2['Fills'] = self.fills
         stats.extend(stat2.items())
-        print(
-            tabulate(
-                stats, 
-                headers=["Metric", "Value"], 
-                tablefmt="outline"), 
-                "\n"
-            )
+        tab_stats = tabulate(stats, headers=["Metric", "Value"], tablefmt="outline")
+        print(tab_stats, "\n")
+        if self.stats_file:
+            with open(self.stats_file, 'a') as f:
+                f.write("\n[======= Summary Stats =======]\n")
+                f.write(tab_stats)
+                f.write("\n")
 
         if self.show_equity:
             print("\nCreating equity curve...")
@@ -336,7 +342,7 @@ def run_backtest_with(engine: Literal["bbstrader", "cerebro", "zipline"], **kwar
             data_handler=kwargs.get("data_handler"),
             strategy=kwargs.get("strategy"),
             exc_handler=kwargs.get("exc_handler"),
-            initial_capital=kwargs.get("initial_capital"),
+            initial_capital=kwargs.get("initial_capital", 100000.0),
             heartbeat=kwargs.get("heartbeat", 0.0),
             **kwargs
         )

{bbstrader-0.1.92 → bbstrader-0.1.93}/bbstrader/btengine/execution.py

@@ -77,8 +77,9 @@ class SimExecutionHandler(ExecutionHandler):
         if event.type == 'ORDER':
             dtime = self.bardata.get_latest_bar_datetime(event.symbol)
             fill_event = FillEvent(
-                dtime, event.symbol,
-                'ARCA', event.quantity, event.direction, order=event.signal
+                timeindex=dtime, symbol=event.symbol,
+                exchange='ARCA', quantity=event.quantity, direction=event.direction,
+                fill_cost=None, commission=None, order=event.signal
             )
             self.events.put(fill_event)
             self.logger.info(

{bbstrader-0.1.92 → bbstrader-0.1.93}/bbstrader/btengine/performance.py

@@ -6,6 +6,8 @@ from scipy.stats import mstats
 import matplotlib.pyplot as plt
 from matplotlib.ticker import MaxNLocator
 import quantstats as qs
+import warnings
+warnings.filterwarnings("ignore")
 
 sns.set_theme()
 

{bbstrader-0.1.92 → bbstrader-0.1.93}/bbstrader/btengine/portfolio.py

@@ -93,16 +93,20 @@ class Portfolio(object):
             initial_capital (float): The starting capital in USD.
 
             kwargs (dict): Additional arguments
+                - `leverage`: The leverage to apply to the portfolio.
                 - `time_frame`: The time frame of the bars.
-                - `trading_hours`: The number of trading hours in a day.
+                - `session_duration`: The number of trading hours in a day.
                 - `benchmark`: The benchmark symbol to compare the portfolio.
-                - `strategy_name`: The name of the strategy  (the name must not include 'Strategy' in it).    
+                - `output_dir`: The directory to save the backtest results.
+                - `strategy_name`: The name of the strategy  (the name must not include 'Strategy' in it). 
+                - `print_stats`: Whether to print the backtest statistics.   
         """
         self.bars = bars
         self.events = events
         self.symbol_list = self.bars.symbol_list
         self.start_date = start_date
         self.initial_capital = initial_capital
+        self._leverage = kwargs.get('leverage', 1)
 
         self.timeframe = kwargs.get("time_frame", "D1")
         self.trading_hours = kwargs.get("session_duration", 23)
@@ -277,8 +281,7 @@ class Portfolio(object):
 
     def generate_order(self, signal: SignalEvent):
         """
-        Check if the portfolio has enough cash to place an order
-        and generate an OrderEvent, else return None.
+        Turns a SignalEvent into an OrderEvent.
 
         Args:
             signal (SignalEvent): The tuple containing Signal information.
@@ -294,25 +297,17 @@ class Portfolio(object):
         strength = signal.strength
         price = signal.price or self._get_price(symbol)
         cur_quantity = self.current_positions[symbol]
-        cash = self.current_holdings['Cash']
+        mkt_quantity = round(quantity * strength, 2)
+        new_quantity = mkt_quantity * self._leverage
 
         if direction in ['LONG', 'SHORT', 'EXIT']:
             order_type = 'MKT'
         else:
             order_type = direction
-        mkt_quantity = round(quantity * strength)
-        cost = mkt_quantity * price
 
-        if cash >= cost:
-            new_quantity = mkt_quantity
-        elif cash < cost and cash > 0:
-            new_quantity =  round(cash // price)
-        else:
-            new_quantity = 0
-
-        if new_quantity > 0 and direction == 'LONG':
+        if  direction == 'LONG' and new_quantity > 0: 
             order = OrderEvent(symbol, order_type, new_quantity, 'BUY', price, direction)
-        if new_quantity > 0 and direction == 'SHORT':
+        if direction == 'SHORT' and new_quantity > 0:
             order = OrderEvent(symbol, order_type, new_quantity, 'SELL', price, direction)
 
         if direction == 'EXIT' and cur_quantity > 0:
@@ -322,6 +317,7 @@ class Portfolio(object):
 
         return order
 
+
     def update_signal(self, event: SignalEvent):
         """
         Acts on a SignalEvent to generate new orders

{bbstrader-0.1.92 → bbstrader-0.1.93}/bbstrader/btengine/strategy.py

@@ -1,6 +1,5 @@
 from abc import ABCMeta, abstractmethod
 import pytz
-import math
 import pandas as pd
 import numpy as np
 from queue import Queue
@@ -18,6 +17,7 @@ from typing import (
     List,
     Literal
 )
+from bbstrader.models.optimization import optimized_weights
 
 __all__ = ['Strategy', 'MT5Strategy']
 
@@ -72,17 +72,29 @@ class MT5Strategy(Strategy):
             bars : The data handler object.
             mode : The mode of operation for the strategy (backtest or live).
             **kwargs : Additional keyword arguments for other classes (e.g, Portfolio, ExecutionHandler).
+                - max_trades : The maximum number of trades allowed per symbol.
+                - time_frame : The time frame for the strategy.
+                - logger : The logger object for the strategy.
         """
         self.events = events
         self.data = bars
         self.symbols = symbol_list
         self.mode = mode
-        self.volume = kwargs.get("volume")
-        self.max_trades = kwargs.get("max_trades",
-                                     {symbol: 1 for symbol in self.symbols})
+        self._porfolio_value = None
+        self.risk_budget = self._check_risk_budget(**kwargs)
+        self.max_trades = kwargs.get("max_trades", {s: 1 for s in self.symbols})
+        self.tf = kwargs.get("time_frame", 'D1')
         self.logger = kwargs.get("logger")
         self._initialize_portfolio()
+
+    @property
+    def cash(self) -> float:
+        return self._porfolio_value
     
+    @cash.setter
+    def cash(self, value):
+        self._porfolio_value = value
+
     @property
     def orders(self) -> Dict[str, Dict[str, List[SignalEvent]]]:
         return self._orders
@@ -98,11 +110,24 @@ class MT5Strategy(Strategy):
     @property
     def holdings(self) -> Dict[str,  float]:
         return self._holdings
+    
+    def _check_risk_budget(self, **kwargs):
+        weights = kwargs.get('risk_weights')
+        if weights is not None and isinstance(weights, dict):
+            for asset in self.symbols:
+                if asset not in weights:
+                    raise ValueError(f"Risk budget for asset {asset} is missing.")
+            total_risk = sum(weights.values())
+            if not np.isclose(total_risk, 1.0):
+                raise ValueError(f'Risk budget weights must sum to 1. got {total_risk}')
+            return weights
+        elif isinstance(weights, str):
+            return weights
 
     def _initialize_portfolio(self):
         positions = ['LONG', 'SHORT']
         orders = ['BLMT', 'BSTP', 'BSTPLMT', 'SLMT', 'SSTP', 'SSTPLMT']
-        self._positions: Dict[str, Dict[str, int]] = {}
+        self._positions: Dict[str, Dict[str, int | float]] = {}
         self._trades: Dict[str, Dict[str, int]] = {}
         self._orders: Dict[str, Dict[str, List[SignalEvent]]] = {}
         for symbol in self.symbols:
@@ -111,7 +136,7 @@ class MT5Strategy(Strategy):
             self._trades[symbol] = {}
             for position in positions:
                 self._trades[symbol][position] = 0
-                self._positions[symbol][position] = 0
+                self._positions[symbol][position] = 0.0
             for order in orders:
                 self._orders[symbol][order] = []
         self._holdings = {s: 0.0 for s in self.symbols}
@@ -133,6 +158,9 @@ class MT5Strategy(Strategy):
                     self._positions[symbol]['LONG'] = positions[symbol]
                 elif positions[symbol] < 0:
                     self._positions[symbol]['SHORT'] = positions[symbol]
+                else:
+                    self._positions[symbol]['LONG'] = 0
+                    self._positions[symbol]['SHORT'] = 0
             if symbol in holdings:
                 self._holdings[symbol] = holdings[symbol]
     
@@ -142,7 +170,12 @@ class MT5Strategy(Strategy):
         It is used to keep track of the number of trades executed for each order.
         """
         if event.type == 'FILL':
-            self._trades[event.symbol][event.order] += 1
+            if event.order != 'EXIT':
+                self._trades[event.symbol][event.order] += 1
+            elif event.order == 'EXIT' and event.direction == 'BUY':
+                self._trades[event.symbol]['SHORT'] = 0
+            elif event.order == 'EXIT' and event.direction == 'SELL':
+                self._trades[event.symbol]['LONG'] = 0
 
     def calculate_signals(self, *args, **kwargs
                           ) -> Dict[str, Union[str, dict, None]] | None:
@@ -173,7 +206,25 @@ class MT5Strategy(Strategy):
         """
         pass
 
-    def get_quantity(self, symbol, volume=None) -> int:
+    def apply_risk_management(self, optimer, freq=252) -> Dict[str, float] | None:
+        """
+        Apply risk management rules to the strategy.
+        """
+        if optimer is None:
+            return None
+        prices = self.get_asset_values(
+            symbol_list=self.symbols, bars=self.data, mode=self.mode, 
+            window=freq, value_type='close', array=False, tf=self.tf
+        )
+        prices = pd.DataFrame(prices)
+        prices = prices.dropna(axis=0, how='any')
+        try:
+            weights = optimized_weights(prices=prices, freq=freq, method=optimer)
+            return {symbol: weight for symbol, weight in weights.items()}
+        except Exception:
+            return {symbol: 0.0 for symbol in self.symbols}
+
+    def get_quantity(self, symbol, weight,   price=None, volume=None, maxqty=None) -> int:
         """
         Calculate the quantity to buy or sell for a given symbol based on the dollar value provided.
         The quantity calculated can be used to evalute a strategy's performance for each symbol
@@ -185,15 +236,26 @@ class MT5Strategy(Strategy):
         Returns:
             qty : The quantity to buy or sell for the symbol.
         """
-        if self.volume is None and volume is None:
-            raise ValueError("Volume must be provided for the method.")
-        current_price = self.data.get_latest_bar_value(symbol, 'close')
-        try:
-            qty = math.ceil(self.volume or volume / current_price)
-            qty = max(qty, 1) / self.max_trades[symbol]
-            return max(math.ceil(qty), 1)
-        except Exception:
-            return 1
+        if (self._porfolio_value is None or weight == 0 or
+            self._porfolio_value == 0 or np.isnan(self._porfolio_value)):
+            return 0
+        if volume is None:
+            volume = round(self._porfolio_value * weight)
+        if price is None:
+            price = self.data.get_latest_bar_value(symbol, 'close')
+        if (price is None or not isinstance(price, (int, float, np.number))
+            or volume is None or not isinstance(volume, (int, float, np.number)) 
+            or np.isnan(float(price))
+            or np.isnan(float(volume))
+        ):
+            if weight != 0:
+                return 1
+            return 0
+        qty = round(volume / price, 2)
+        qty = max(qty, 0) / self.max_trades[symbol]
+        if maxqty is not None:
+            qty = min(qty, maxqty)
+        return max(round(qty, 2), 0)
     
     def get_quantities(self, quantities: Union[None, dict, int]) -> dict:
         """
@@ -215,9 +277,18 @@ class MT5Strategy(Strategy):
 
         position = SignalEvent(id, symbol, dtime, signal,
                                quantity=quantity, strength=strength, price=price)
-        self.events.put(position)
-        self.logger.info(
-            f"{signal} ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={quantity}, PRICE @{price}", custom_time=dtime)
+        log = False
+        if signal in ['LONG', 'SHORT']:
+            if self._trades[symbol][signal] < self.max_trades[symbol] and quantity > 0:
+                self.events.put(position)
+                log = True
+        elif signal == 'EXIT':
+            if self._positions[symbol]['LONG'] > 0 or self._positions[symbol]['SHORT'] < 0:
+                self.events.put(position)
+                log = True
+        if log:
+            self.logger.info(
+                f"{signal} ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={quantity}, PRICE @{price}", custom_time=dtime)
 
     def buy_mkt(self, id: int, symbol: str, price: float, quantity: int, 
             strength: float=1.0, dtime: datetime | pd.Timestamp=None):
@@ -341,55 +412,79 @@ class MT5Strategy(Strategy):
         """
         for symbol in self.symbols:
             dtime = self.data.get_latest_bar_datetime(symbol)
+            logmsg = lambda order, type: self.logger.info(
+                f"{type} ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={order.quantity}, "
+                f"PRICE @ {order.price}", custom_time=dtime)
             for order in self._orders[symbol]['BLMT'].copy():
                 if self.data.get_latest_bar_value(symbol, 'close') <= order.price:
                     self.buy_mkt(order.strategy_id, symbol,
                              order.price, order.quantity, dtime)
-                    self.logger.info(
-                        f"BUY LIMIT ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={order.quantity}, "
-                        f"PRICE @ {order.price}", custom_time=dtime)
-                    self._orders[symbol]['BLMT'].remove(order)
+                    try:
+                        self._orders[symbol]['BLMT'].remove(order)
+                        assert order not in self._orders[symbol]['BLMT']
+                        logmsg(order, 'BUY LIMIT')
+                    except AssertionError:
+                        self._orders[symbol]['BLMT'] = [o for o in self._orders[symbol]['BLMT'] if o != order]
+                        logmsg(order, 'BUY LIMIT')
             for order in self._orders[symbol]['SLMT'].copy():
                 if self.data.get_latest_bar_value(symbol, 'close') >= order.price:
                     self.sell_mkt(order.strategy_id, symbol,
                               order.price, order.quantity, dtime)
-                    self.logger.info(
-                        f"SELL LIMIT ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={order.quantity}, "
-                        f"PRICE @ {order.price}", custom_time=dtime)
-                    self._orders[symbol]['SLMT'].remove(order)
+                    try:
+                        self._orders[symbol]['SLMT'].remove(order)
+                        assert order not in self._orders[symbol]['SLMT']
+                        logmsg(order, 'SELL LIMIT')
+                    except AssertionError:
+                        self._orders[symbol]['SLMT'] = [o for o in self._orders[symbol]['SLMT'] if o != order]
+                        logmsg(order, 'SELL LIMIT')
             for order in self._orders[symbol]['BSTP'].copy():
                 if self.data.get_latest_bar_value(symbol, 'close') >= order.price:
                     self.buy_mkt(order.strategy_id, symbol,
                              order.price, order.quantity, dtime)
-                    self.logger.info(
-                        f"BUY STOP ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={order.quantity}, "
-                        f"PRICE @ {order.price}", custom_time=dtime)
-                    self._orders[symbol]['BSTP'].remove(order)
+                    try:
+                        self._orders[symbol]['BSTP'].remove(order)
+                        assert order not in self._orders[symbol]['BSTP']
+                        logmsg(order, 'BUY STOP')
+                    except AssertionError:
+                        self._orders[symbol]['BSTP'] = [o for o in self._orders[symbol]['BSTP'] if o != order]
+                        logmsg(order, 'BUY STOP')
             for order in self._orders[symbol]['SSTP'].copy():
                 if self.data.get_latest_bar_value(symbol, 'close') <= order.price:
                     self.sell_mkt(order.strategy_id, symbol,
                               order.price, order.quantity, dtime)
-                    self.logger.info(
-                        f"SELL STOP ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={order.quantity}, "
-                        f"PRICE @ {order.price}", custom_time=dtime)
-                    self._orders[symbol]['SSTP'].remove(order)
+                    try:
+                        self._orders[symbol]['SSTP'].remove(order)
+                        assert order not in self._orders[symbol]['SSTP']
+                        logmsg(order, 'SELL STOP')
+                    except AssertionError:
+                        self._orders[symbol]['SSTP'] = [o for o in self._orders[symbol]['SSTP'] if o != order]
+                        logmsg(order, 'SELL STOP')
             for order in self._orders[symbol]['BSTPLMT'].copy():
                 if self.data.get_latest_bar_value(symbol, 'close') >= order.price:
                     self.buy_limit(order.strategy_id, symbol,
                                    order.stoplimit, order.quantity, dtime)
-                    self.logger.info(
-                        f"BUY STOP LIMIT ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={order.quantity}, "
-                        f"PRICE @ {order.price}", custom_time=dtime)
-                    self._orders[symbol]['BSTPLMT'].remove(order)
+                    try:
+                        self._orders[symbol]['BSTPLMT'].remove(order)
+                        assert order not in self._orders[symbol]['BSTPLMT']
+                        logmsg(order, 'BUY STOP LIMIT')
+                    except AssertionError:
+                        self._orders[symbol]['BSTPLMT'] = [o for o in self._orders[symbol]['BSTPLMT'] if o != order]
+                        logmsg(order, 'BUY STOP LIMIT')
             for order in self._orders[symbol]['SSTPLMT'].copy():
                 if self.data.get_latest_bar_value(symbol, 'close') <= order.price:
                     self.sell_limit(order.strategy_id, symbol,
                                     order.stoplimit, order.quantity, dtime)
-                    self.logger.info(
-                        f"SELL STOP LIMIT ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={order.quantity}, "
-                        f"PRICE @ {order.price}", custom_time=dtime)
-                    self._orders[symbol]['SSTPLMT'].remove(order)
-
+                    try:
+                        self._orders[symbol]['SSTPLMT'].remove(order)
+                        assert order not in self._orders[symbol]['SSTPLMT']
+                        logmsg(order, 'SELL STOP LIMIT')
+                    except AssertionError:
+                        self._orders[symbol]['SSTPLMT'] = [o for o in self._orders[symbol]['SSTPLMT'] if o != order]
+                        logmsg(order, 'SELL STOP LIMIT')
+
+    def calculate_pct_change(self, current_price, lh_price):
+        return ((current_price - lh_price) / lh_price) * 100
+    
     def get_asset_values(self,
                           symbol_list: List[str],
                           window: int,

{bbstrader-0.1.92 → bbstrader-0.1.93}/bbstrader/metatrader/account.py

@@ -688,7 +688,7 @@ class Account(object):
                 "minors": r"\b(Minors?)\b",
                 "exotics": r"\b(Exotics?)\b",
             }
-            return self._get_symbols_by_category('forex', category, fx_categories)
+            return self._get_symbols_by_category('FX', category, fx_categories)
 
     def get_stocks_from_country(self, country_code: str = 'USA', etf=True) -> List[str]:
         """

{bbstrader-0.1.92 → bbstrader-0.1.93}/bbstrader/metatrader/risk.py

@@ -156,6 +156,22 @@ class RiskManagement(Account):
         self.symbol_info = super().get_symbol_info(self.symbol)
 
         self._tf = time_frame
+
+    @property
+    def dailydd(self) -> float:
+        return self.daily_dd
+
+    @dailydd.setter
+    def dailydd(self, value: float):
+        self.daily_dd = value
+    
+    @property
+    def maxrisk(self) -> float:
+        return self.max_risk
+    
+    @maxrisk.setter
+    def maxrisk(self, value: float):
+        self.max_risk = value
     
     def _convert_time_frame(self, tf: str) -> int:
         """Convert time frame to minutes"""
@@ -437,14 +453,23 @@ class RiskManagement(Account):
         if trade_risk > 0:
             currency_risk = round(self.var_loss_value(), 5)
             volume = round(currency_risk*laverage)
-            _lot = round((volume / (contract_size * av_price)), 2)
+            try:
+                _lot = round((volume / (contract_size * av_price)), 2)
+            except ZeroDivisionError:
+                _lot = 0.0
             lot = self._check_lot(_lot)
             if COMD and contract_size > 1:
                 # lot = volume / av_price / contract_size
-                lot = volume / av_price / contract_size
+                try:
+                    lot = volume / av_price / contract_size
+                except ZeroDivisionError:
+                    lot = 0.0
                 lot = self._check_lot(_lot)
             if FX:
-                __lot = round((volume / contract_size), 2)
+                try:
+                    __lot = round((volume / contract_size), 2)
+                except ZeroDivisionError:
+                    __lot = 0.0
                 lot = self._check_lot(__lot)
 
             tick_value = s_info.trade_tick_value

{bbstrader-0.1.92 → bbstrader-0.1.93}/bbstrader/models/__init__.py

@@ -3,4 +3,8 @@ The `models` module provides a foundational framework for implementing various q
 
 It is designed to be a versatile base module for different types of models used in financial analysis and trading. 
 """
-from bbstrader.models.risk import *
+from bbstrader.models.risk import *
+from bbstrader.models.optimization import *
+from bbstrader.models.portfolios import *
+from bbstrader.models.factors import *
+from bbstrader.models.ml import *

{bbstrader-0.1.92 → bbstrader-0.1.93}/bbstrader/models/optimization.py

@@ -6,7 +6,14 @@ from pypfopt.efficient_frontier import EfficientFrontier
 from pypfopt.hierarchical_portfolio import HRPOpt
 import warnings
 
-def markowitz_weights(prices=None, freq=252):
+__all__ = [
+    'markowitz_weights', 
+    'hierarchical_risk_parity', 
+    'equal_weighted', 
+    'optimized_weights'
+]
+
+def markowitz_weights(prices=None, rfr=0.0, freq=252):
     """
     Calculates optimal portfolio weights using Markowitz's mean-variance optimization (Max Sharpe Ratio) with multiple solvers.
 
@@ -45,7 +52,7 @@ def markowitz_weights(prices=None, freq=252):
                                weight_bounds=(0, 1),
                                solver=solver)
         try:
-            weights = ef.max_sharpe()
+            weights = ef.max_sharpe(risk_free_rate=rfr)
             return ef.clean_weights()
         except Exception as e:
             print(f"Solver {solver} failed with error: {e}")
@@ -83,7 +90,7 @@ def hierarchical_risk_parity(prices=None, returns=None, freq=252):
     if returns is None and prices is None:
         raise ValueError("Either prices or returns must be provided")
     if returns is None:
-        returns = prices.pct_change().dropna()
+        returns = prices.pct_change().dropna(how='all')
     # Remove duplicate columns and index
     returns = returns.loc[:, ~returns.columns.duplicated()]
     returns = returns.loc[~returns.index.duplicated(keep='first')]
@@ -128,7 +135,7 @@ def equal_weighted(prices=None, returns=None, round_digits=5):
         columns = returns.columns
     return {col: round(1/n, round_digits) for col in columns}
 
-def optimized_weights(prices=None, returns=None, freq=252, method='markowitz'):
+def optimized_weights(prices=None, returns=None, rfr=0.0, freq=252, method='equal'):
     """
     Selects an optimization method to calculate portfolio weights based on user preference.
 
@@ -161,7 +168,7 @@ def optimized_weights(prices=None, returns=None, freq=252, method='markowitz'):
     - 'equal': Equal weighting across all assets
     """
     if method == 'markowitz':
-        return markowitz_weights(prices=prices, freq=freq)
+        return markowitz_weights(prices=prices, rfr=rfr, freq=freq)
     elif method == 'hrp':
         return hierarchical_risk_parity(prices=prices, returns=returns, freq=freq)
     elif method == 'equal':

{bbstrader-0.1.92 → bbstrader-0.1.93}/bbstrader/models/portfolios.py

@@ -10,6 +10,9 @@ from bbstrader.models.optimization import (
     equal_weighted
 )
 
+__all__ = [
+    'EigenPortfolios'
+]
 
 class EigenPortfolios(object):
     """

{bbstrader-0.1.92 → bbstrader-0.1.93}/bbstrader/trading/execution.py

@@ -78,10 +78,11 @@ EXIT_SIGNAL_ACTIONS = {
 
 def _mt5_execution(
         symbol_list, trades_instances, strategy_cls, /,
-        mm, trail, stop_trail, trail_after_points, be_plus_points, show_positions_orders,
-        time_frame, iter_time, use_trade_time, period, period_end_action, closing_pnl, trading_days,
+        mm, optimizer, trail, stop_trail, trail_after_points, be_plus_points, show_positions_orders,
+        iter_time, use_trade_time, period, period_end_action, closing_pnl, trading_days,
         comment, **kwargs):
     symbols  = symbol_list.copy()
+    time_frame = kwargs.get('time_frame', '15m')
     STRATEGY = kwargs.get('strategy_name')
     mtrades  = kwargs.get('max_trades')
     notify   = kwargs.get('notify', False)
@@ -89,6 +90,14 @@ def _mt5_execution(
         telegram  = kwargs.get('telegram', False)
         bot_token = kwargs.get('bot_token')
         chat_id   = kwargs.get('chat_id')
+    
+    def update_risk(weights):
+        if weights is not None:
+            for symbol in symbols:
+                if symbol not in weights:
+                    continue
+                trade = trades_instances[symbol]
+                trade.dailydd = round(weights[symbol], 5)
 
     def _send_notification(signal):
         send_message(message=signal, notify_me=notify, 
@@ -160,6 +169,8 @@ def _mt5_execution(
         try:
             check_mt5_connection()
             signals = strategy.calculate_signals()
+            weights = strategy.apply_risk_management(optimizer)
+            update_risk(weights)
         except Exception as e:
             logger.error(f"Calculating signal, {e}, STRATEGY={STRATEGY}")
             continue
@@ -181,7 +192,7 @@ def _mt5_execution(
                     if signal is not None:
                         signal = 'BMKT' if signal == 'LONG' else signal
                         signal = 'SMKT' if signal == 'SHORT' else signal
-                        info = f"SIGNAL = {signal}, SYMBOL={trade.symbol}, STRATEGY={STRATEGY}"
+                        info = f"SIGNAL = {signal}, SYMBOL={trade.symbol}, STRATEGY={STRATEGY}, TIMEFRAME={time_frame}"
                         msg = f"Sending {signal} Order ... SYMBOL={trade.symbol}, STRATEGY={STRATEGY}"
                         if signal not in EXIT_SIGNAL_ACTIONS:
                             logger.info(info)
@@ -436,12 +447,12 @@ class MT5ExecutionEngine():
                  strategy_cls:       Strategy,
                  /,
                  mm:                 bool = True,
+                 optimizer:          str = 'equal',
                  trail:              bool = True,
                  stop_trail:         Optional[int] = None,
                  trail_after_points: Optional[int] = None,
                  be_plus_points:     Optional[int] = None,
                  show_positions_orders: bool = False,
-                 time_frame:         str = '15m',
                  iter_time:          int | float = 5,
                  use_trade_time:     bool = True,
                  period:             Literal['day', 'week', 'month'] = 'week',
@@ -457,8 +468,9 @@ class MT5ExecutionEngine():
             trades_instances : Dictionary of Trade instances
             strategy_cls : Strategy class to use for trading
             mm : Enable Money Management. Defaults to False.
+            optimizer : Risk management optimizer. Defaults to 'equal'.
+                See `bbstrader.models.optimization` module for more information.
             show_positions_orders : Print open positions and orders. Defaults to False.
-            time_frame : Time frame to trade. Defaults to '15m'.
             iter_time : Interval to check for signals and `mm`. Defaults to 5.
             use_trade_time : Open trades after the time is completed. Defaults to True.
             period : Period to trade. Defaults to 'week'.
@@ -468,6 +480,7 @@ class MT5ExecutionEngine():
             trading_days : Trading days in a week. Defaults to monday to friday.
             comment: Comment for trades. Defaults to None.
             **kwargs: Additional keyword arguments
+                _ time_frame : Time frame to trade. Defaults to '15m'.
                 - strategy_name (Optional[str]): Strategy name. Defaults to None.
                 - max_trades (Dict[str, int]): Maximum trades per symbol. Defaults to None.
                 - notify (bool): Enable notifications. Defaults to False.
@@ -497,12 +510,12 @@ class MT5ExecutionEngine():
         self.trades_instances = trades_instances
         self.strategy_cls = strategy_cls
         self.mm = mm
+        self.optimizer = optimizer
         self.trail = trail
         self.stop_trail = stop_trail
         self.trail_after_points = trail_after_points
         self.be_plus_points = be_plus_points
         self.show_positions_orders = show_positions_orders
-        self.time_frame = time_frame
         self.iter_time = iter_time
         self.use_trade_time = use_trade_time
         self.period = period
@@ -519,12 +532,12 @@ class MT5ExecutionEngine():
             self.trades_instances,
             self.strategy_cls,
             mm=self.mm,
+            optimizer=self.optimizer,
             trail=self.trail,
             stop_trail=self.stop_trail,
             trail_after_points=self.trail_after_points,
             be_plus_points=self.be_plus_points,
             show_positions_orders=self.show_positions_orders,
-            time_frame=self.time_frame,
             iter_time=self.iter_time,
             use_trade_time=self.use_trade_time,
             period=self.period,

{bbstrader-0.1.92 → bbstrader-0.1.93/bbstrader.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bbstrader
-Version: 0.1.92
+Version: 0.1.93
 Summary: Simplified Investment & Trading Toolkit
 Home-page: https://github.com/bbalouki/bbstrader
 Download-URL: https://pypi.org/project/bbstrader/

{bbstrader-0.1.92 → bbstrader-0.1.93}/setup.py

@@ -17,7 +17,7 @@ with io.open(path.join(here, 'README.md'), encoding='utf-8') as f:
 with io.open(path.join(here, 'requirements.txt'), encoding='utf-8') as f:
     REQUIREMENTS = [line.rstrip() for line in f]
 
-VERSION = '0.1.92'
+VERSION = '0.1.93'
 DESCRIPTION = 'Simplified Investment & Trading Toolkit'
 
 KEYWORDS = [