bbstrader 0.1.91__py3-none-any.whl → 0.1.92__py3-none-any.whl

bbstrader/btengine/backtest.py

@@ -111,8 +111,9 @@ class BacktestEngine(Backtest):
         their class types.
         """
         print(
-            f"\nStarting Backtest on {self.symbol_list} "
-            f"with ${self.initial_capital} Initial Capital\n"
+            f"\n[=======   STARTING BACKTEST   =======]\n"
+            f"START DATE: {self.start_date} \n"
+            f"INITIAL CAPITAL: {self.initial_capital}\n"
         )
         self.data_handler: DataHandler = self.dh_cls(
             self.events, self.symbol_list, **self.kwargs
@@ -141,8 +142,9 @@ class BacktestEngine(Backtest):
                 self.data_handler.update_bars()
                 self.strategy.check_pending_orders()
             else:
-                print("\n[======= BACKTEST COMPLETE =======]\n")
-                print(f"Total bars: {i} ")
+                print("\n[======= BACKTEST COMPLETED =======]")
+                print(f"END DATE: {self.data_handler.get_latest_bar_datetime()}")
+                print(f"TOTAL BARS: {i} ")
                 break
 
             # Handle the events
@@ -168,6 +170,11 @@ class BacktestEngine(Backtest):
                         elif event.type == 'FILL':
                             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)
 

bbstrader/btengine/data.py

@@ -272,7 +272,11 @@ class BaseCSVDataHandler(DataHandler):
             print("Symbol not available in the historical data set.")
             raise
         else:
-            return getattr(bars_list[-1][1], val_type)
+            try:
+                return getattr(bars_list[-1][1], val_type)
+            except AttributeError:
+                print(f"Value type {val_type} not available in the historical data set.")
+                raise
 
     def get_latest_bars_values(self, symbol: str, val_type: str, N=1) -> np.ndarray:
         """
@@ -285,7 +289,11 @@ class BaseCSVDataHandler(DataHandler):
             print("That symbol is not available in the historical data set.")
             raise
         else:
-            return np.array([getattr(b[1], val_type) for b in bars_list])
+            try:
+                return np.array([getattr(b[1], val_type) for b in bars_list])
+            except AttributeError:
+                print(f"Value type {val_type} not available in the historical data set.")
+                raise
 
     def update_bars(self):
         """

bbstrader/btengine/event.py

@@ -102,14 +102,15 @@ class OrderEvent(Event):
 
     def __init__(self,
                  symbol: str,
-                 order_type: Literal['MKT', 'LMT'],
+                 order_type: Literal['MKT', 'LMT', 'STP', 'STPLMT'],
                  quantity: int | float,
                  direction: Literal['BUY', 'SELL'],
-                 price: int | float = None
+                 price: int | float = None,
+                 signal: str = None
                  ):
         """
         Initialises the order type, setting whether it is
-        a Market order ('MKT') or Limit order ('LMT'), has
+        a Market order ('MKT') or Limit order ('LMT'), or Stop order ('STP').
         a quantity (integral or float) and its direction ('BUY' or 'SELL').
 
         Args:
@@ -118,6 +119,7 @@ class OrderEvent(Event):
             quantity (int | float): Non-negative number for quantity.            
             direction (str): 'BUY' or 'SELL' for long or short.
             price (int | float): The price at which to order.
+            signal (str): The signal that generated the order.
         """
         self.type = 'ORDER'
         self.symbol = symbol
@@ -125,6 +127,7 @@ class OrderEvent(Event):
         self.quantity = quantity
         self.direction = direction
         self.price = price
+        self.signal = signal
 
         def print_order(self):
             """
@@ -162,7 +165,8 @@ class FillEvent(Event):
                  quantity: int | float,
                  direction: Literal['BUY', 'SELL'],
                  fill_cost: int | float | None,
-                 commission: float | None = None
+                 commission: float | None = None,
+                 order: str = None
                  ):
         """
         Initialises the FillEvent object. Sets the symbol, exchange,
@@ -181,6 +185,7 @@ class FillEvent(Event):
             direction (str): The direction of fill `('LONG', 'SHORT', 'EXIT')`
             fill_cost (int | float): Price of the shares when filled.
             commission (float | None): An optional commission sent from IB.
+            order (str): The order that this fill is related
         """
         self.type = 'FILL'
         self.timeindex = timeindex
@@ -194,6 +199,7 @@ class FillEvent(Event):
             self.commission = self.calculate_ib_commission()
         else:
             self.commission = commission
+        self.order = order
 
     def calculate_ib_commission(self):
         """

bbstrader/btengine/execution.py

@@ -4,7 +4,6 @@ from abc import ABCMeta, abstractmethod
 from bbstrader.btengine.event import FillEvent, OrderEvent
 from bbstrader.btengine.data import DataHandler
 from bbstrader.metatrader.account import Account
-from bbstrader.config import config_logger
 
 __all__ = [
     "ExecutionHandler",
@@ -26,7 +25,8 @@ class ExecutionHandler(metaclass=ABCMeta):
 
     The ExecutionHandler described here is exceedingly simple, 
     since it fills all orders at the current market price. 
-    This is highly unrealistic, but serves as a good baseline for improvement.
+    This is highly unrealistic, for other markets thant ``CFDs`` 
+    but serves as a good baseline for improvement.
     """
 
     @abstractmethod
@@ -64,7 +64,7 @@ class SimExecutionHandler(ExecutionHandler):
         """
         self.events = events
         self.bardata = data
-        self.logger = kwargs.get("logger", config_logger("execution.log"))
+        self.logger = kwargs.get("logger")
 
     def execute_order(self, event: OrderEvent):
         """
@@ -78,7 +78,7 @@ class SimExecutionHandler(ExecutionHandler):
             dtime = self.bardata.get_latest_bar_datetime(event.symbol)
             fill_event = FillEvent(
                 dtime, event.symbol,
-                'ARCA', event.quantity, event.direction, None
+                'ARCA', event.quantity, event.direction, order=event.signal
             )
             self.events.put(fill_event)
             self.logger.info(
@@ -121,7 +121,7 @@ class MT5ExecutionHandler(ExecutionHandler):
         """
         self.events = events
         self.bardata = data
-        self.logger = kwargs.get("logger", config_logger("execution.log"))
+        self.logger = kwargs.get("logger")
         self.__account = Account()
 
     def _calculate_lot(self, symbol, quantity, price):
@@ -232,7 +232,7 @@ class MT5ExecutionHandler(ExecutionHandler):
             fill_event = FillEvent(
                 timeindex=dtime, symbol=symbol,
                 exchange='MT5', quantity=quantity, direction=direction,
-                fill_cost=None, commission=fees
+                fill_cost=None, commission=fees, order=event.signal
             )
             self.events.put(fill_event)
             self.logger.info(

bbstrader/btengine/portfolio.py

@@ -31,8 +31,6 @@ class Portfolio(object):
     """
     This  describes a `Portfolio()` object that keeps track of the positions 
     within a portfolio and generates orders of a fixed quantity of stock based on signals. 
-    More sophisticated portfolio objects could include risk management and position 
-    sizing tools (such as the `Kelly Criterion`).
 
     The portfolio order management system is possibly the most complex component of 
     an event driven backtester. Its role is to keep track of all current market positions 
@@ -57,10 +55,9 @@ class Portfolio(object):
     value (defaulting to `100,000 USD`) and others parameter based on the `Strategy` requirement.
 
     The `Portfolio` is designed to handle position sizing and current holdings, 
-    but will carry out trading orders in a "dumb" manner by simply sending them directly 
-    to the brokerage with a predetermined fixed quantity size, irrespective of cash held. 
-    These are all unrealistic assumptions, but they help to outline how a portfolio order 
-    management system (OMS) functions in an eventdriven fashion.
+    but will carry out trading orders by simply them to the brokerage with a predetermined 
+    fixed quantity size, if the portfolio has enough cash to place the order.
+
 
     The portfolio contains the `all_positions` and `current_positions` members. 
     The former stores a list of all previous positions recorded at the timestamp of a market data event. 
@@ -108,7 +105,7 @@ class Portfolio(object):
         self.initial_capital = initial_capital
 
         self.timeframe = kwargs.get("time_frame", "D1")
-        self.trading_hours = kwargs.get("session_duration", 6.5)
+        self.trading_hours = kwargs.get("session_duration", 23)
         self.benchmark = kwargs.get('benchmark', 'SPY')
         self.output_dir = kwargs.get('output_dir', None)
         self.strategy_name = kwargs.get('strategy_name', '')
@@ -174,6 +171,23 @@ class Portfolio(object):
         d['Commission'] = 0.0
         d['Total'] = self.initial_capital
         return d
+    
+    def _get_price(self, symbol: str) -> float:
+        try:
+            price = self.bars.get_latest_bar_value(
+                symbol, "adj_close"
+            )
+            return price
+        except AttributeError:
+            try:
+                price = self.bars.get_latest_bar_value(
+                    symbol, "close"
+                )
+                return price
+            except AttributeError:
+                raise AttributeError(
+                    f"Bars object must have 'adj_close' or 'close' prices"
+                )
 
     def update_timeindex(self, event: MarketEvent):
         """
@@ -203,8 +217,8 @@ class Portfolio(object):
         dh['Total'] = self.current_holdings['Cash']
         for s in self.symbol_list:
             # Approximation to the real value
-            market_value = self.current_positions[s] * \
-                self.bars.get_latest_bar_value(s, "adj_close")
+            price = self._get_price(s)
+            market_value = self.current_positions[s] * price
             dh[s] = market_value
             dh['Total'] += market_value
 
@@ -245,9 +259,7 @@ class Portfolio(object):
             fill_dir = -1
 
         # Update holdings list with new quantities
-        price = self.bars.get_latest_bar_value(
-            fill.symbol, "adj_close"
-        )
+        price = self._get_price(fill.symbol)
         cost = fill_dir * price * fill.quantity
         self.current_holdings[fill.symbol] += cost
         self.current_holdings['Commission'] += fill.commission
@@ -263,14 +275,16 @@ class Portfolio(object):
             self.update_positions_from_fill(event)
             self.update_holdings_from_fill(event)
 
-    def generate_naive_order(self, signal: SignalEvent):
+    def generate_order(self, signal: SignalEvent):
         """
-        Simply files an Order object as a constant quantity
-        sizing of the signal object, without risk management or
-        position sizing considerations.
+        Check if the portfolio has enough cash to place an order
+        and generate an OrderEvent, else return None.
 
         Args:
             signal (SignalEvent): The tuple containing Signal information.
+        
+        Returns:
+            OrderEvent: The OrderEvent to be executed.
         """
         order = None
 
@@ -278,21 +292,33 @@ class Portfolio(object):
         direction = signal.signal_type
         quantity = signal.quantity
         strength = signal.strength
-        price = signal.price
+        price = signal.price or self._get_price(symbol)
         cur_quantity = self.current_positions[symbol]
+        cash = self.current_holdings['Cash']
 
-        order_type = 'MKT'
+        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 direction == 'LONG' and cur_quantity == 0:
-            order = OrderEvent(symbol, order_type, mkt_quantity, 'BUY', price)
-        if direction == 'SHORT' and cur_quantity == 0:
-            order = OrderEvent(symbol, order_type, mkt_quantity, 'SELL', price)
+        if new_quantity > 0 and direction == 'LONG':
+            order = OrderEvent(symbol, order_type, new_quantity, 'BUY', price, direction)
+        if new_quantity > 0 and direction == 'SHORT':
+            order = OrderEvent(symbol, order_type, new_quantity, 'SELL', price, direction)
 
         if direction == 'EXIT' and cur_quantity > 0:
-            order = OrderEvent(symbol, order_type, abs(cur_quantity), 'SELL', price)
+            order = OrderEvent(symbol, order_type, abs(cur_quantity), 'SELL', price, direction)
         if direction == 'EXIT' and cur_quantity < 0:
-            order = OrderEvent(symbol, order_type, abs(cur_quantity), 'BUY', price)
+            order = OrderEvent(symbol, order_type, abs(cur_quantity), 'BUY', price, direction)
 
         return order
 
@@ -302,7 +328,7 @@ class Portfolio(object):
         based on the portfolio logic.
         """
         if event.type == 'SIGNAL':
-            order_event = self.generate_naive_order(event)
+            order_event = self.generate_order(event)
             self.events.put(order_event)
 
     def create_equity_curve_dataframe(self):

bbstrader/btengine/strategy.py

@@ -7,6 +7,7 @@ from queue import Queue
 from datetime import datetime
 from bbstrader.config import config_logger
 from bbstrader.btengine.event import SignalEvent
+from bbstrader.btengine.event import FillEvent
 from bbstrader.btengine.data import DataHandler
 from bbstrader.metatrader.account import Account
 from bbstrader.metatrader.rates import Rates
@@ -38,6 +39,8 @@ class Strategy(metaclass=ABCMeta):
 
     The strategy hierarchy is relatively simple as it consists of an abstract 
     base class with a single pure virtual method for generating `SignalEvent` objects. 
+    Other methods are provided to check for pending orders, update trades from fills,
+    and get updates from the portfolio.
     """
 
     @abstractmethod
@@ -45,8 +48,9 @@ class Strategy(metaclass=ABCMeta):
         raise NotImplementedError(
             "Should implement calculate_signals()"
         )
-
-    def check_pending_orders(self): ...
+    def check_pending_orders(self, *args, **kwargs): ...
+    def get_update_from_portfolio(self, *args, **kwargs): ...
+    def update_trades_from_fill(self, *args, **kwargs): ...
 
 
 class MT5Strategy(Strategy):
@@ -74,17 +78,71 @@ class MT5Strategy(Strategy):
         self.symbols = symbol_list
         self.mode = mode
         self.volume = kwargs.get("volume")
-        self.logger = kwargs.get("logger", config_logger("mt5_strategy.log"))
-        self._construct_positions_and_orders()
+        self.max_trades = kwargs.get("max_trades",
+                                     {symbol: 1 for symbol in self.symbols})
+        self.logger = kwargs.get("logger")
+        self._initialize_portfolio()
+    
+    @property
+    def orders(self) -> Dict[str, Dict[str, List[SignalEvent]]]:
+        return self._orders
+    
+    @property
+    def trades(self) -> Dict[str, Dict[str, int]]:
+        return self._trades
+
+    @property
+    def positions(self) -> Dict[str, Dict[str, int|float]]:
+        return self._positions
+    
+    @property
+    def holdings(self) -> Dict[str,  float]:
+        return self._holdings
 
-    def _construct_positions_and_orders(self):
-        self.positions: Dict[str, Dict[str, int]] = {}
-        self.orders: Dict[str, Dict[str, List[SignalEvent]]] = {}
+    def _initialize_portfolio(self):
         positions = ['LONG', 'SHORT']
         orders = ['BLMT', 'BSTP', 'BSTPLMT', 'SLMT', 'SSTP', 'SSTPLMT']
+        self._positions: Dict[str, Dict[str, int]] = {}
+        self._trades: Dict[str, Dict[str, int]] = {}
+        self._orders: Dict[str, Dict[str, List[SignalEvent]]] = {}
         for symbol in self.symbols:
-            self.positions[symbol] = {position: 0 for position in positions}
-            self.orders[symbol] = {order: [] for order in orders}
+            self._positions[symbol] = {}
+            self._orders[symbol] = {}
+            self._trades[symbol] = {}
+            for position in positions:
+                self._trades[symbol][position] = 0
+                self._positions[symbol][position] = 0
+            for order in orders:
+                self._orders[symbol][order] = []
+        self._holdings = {s: 0.0 for s in self.symbols}
+        
+    def get_update_from_portfolio(self, positions, holdings):
+        """
+        Update the positions and holdings for the strategy from the portfolio.
+
+        Positions are the number of shares of a security that are owned in long or short.
+        Holdings are the value (postions * price) of the security that are owned in long or short.
+
+        Args:
+            positions : The positions for the symbols in the strategy.
+            holdings : The holdings for the symbols in the strategy.
+        """
+        for symbol in self.symbols:
+            if symbol in positions:
+                if positions[symbol] > 0:
+                    self._positions[symbol]['LONG'] = positions[symbol]
+                elif positions[symbol] < 0:
+                    self._positions[symbol]['SHORT'] = positions[symbol]
+            if symbol in holdings:
+                self._holdings[symbol] = holdings[symbol]
+    
+    def update_trades_from_fill(self, event: FillEvent):
+        """
+        This method updates the trades for the strategy based on the fill event.
+        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
 
     def calculate_signals(self, *args, **kwargs
                           ) -> Dict[str, Union[str, dict, None]] | None:
@@ -115,7 +173,7 @@ class MT5Strategy(Strategy):
         """
         pass
 
-    def get_quantity(self, symbol) -> int:
+    def get_quantity(self, symbol, volume=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
@@ -127,11 +185,15 @@ class MT5Strategy(Strategy):
         Returns:
             qty : The quantity to buy or sell for the symbol.
         """
-        if self.volume is None:
+        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')
-        qty = math.ceil(self.volume / current_price)
-        return max(qty, 1)
+        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
     
     def get_quantities(self, quantities: Union[None, dict, int]) -> dict:
         """
@@ -157,7 +219,7 @@ class MT5Strategy(Strategy):
         self.logger.info(
             f"{signal} ORDER EXECUTED: SYMBOL={symbol}, QUANTITY={quantity}, PRICE @{price}", custom_time=dtime)
 
-    def buy(self, id: int, symbol: str, price: float, quantity: int, 
+    def buy_mkt(self, id: int, symbol: str, price: float, quantity: int, 
             strength: float=1.0, dtime: datetime | pd.Timestamp=None):
         """
         Open a long position
@@ -165,25 +227,22 @@ class MT5Strategy(Strategy):
         See `bbstrader.btengine.event.SignalEvent` for more details on arguments.
         """
         self._send_order(id, symbol, 'LONG', strength, price, quantity, dtime)
-        self.positions[symbol]['LONG'] += quantity
 
-    def sell(self, id, symbol, price, quantity, strength=1.0, dtime=None):
+    def sell_mkt(self, id, symbol, price, quantity, strength=1.0, dtime=None):
         """
         Open a short position
 
         See `bbstrader.btengine.event.SignalEvent` for more details on arguments.
         """
         self._send_order(id, symbol, 'SHORT', strength,  price, quantity, dtime)
-        self.positions[symbol]['SHORT'] += quantity
 
-    def close(self, id, symbol, price, quantity, strength=1.0, dtime=None):
+    def close_positions(self, id, symbol, price, quantity, strength=1.0, dtime=None):
         """
-        Close a position
+        Close a position or exit all positions
 
         See `bbstrader.btengine.event.SignalEvent` for more details on arguments.
         """
         self._send_order(id, symbol, 'EXIT', strength, price, quantity, dtime)
-        self.positions[symbol]['LONG'] -= quantity
 
     def buy_stop(self, id, symbol, price, quantity, strength=1.0, dtime=None):
         """
@@ -197,7 +256,7 @@ class MT5Strategy(Strategy):
                 "The buy_stop price must be greater than the current price.")
         order = SignalEvent(id, symbol, dtime, 'LONG',
                             quantity=quantity, strength=strength, price=price)
-        self.orders[symbol]['BSTP'].append(order)
+        self._orders[symbol]['BSTP'].append(order)
 
     def sell_stop(self, id, symbol, price, quantity, strength=1.0, dtime=None):
         """
@@ -211,7 +270,7 @@ class MT5Strategy(Strategy):
                 "The sell_stop price must be less than the current price.")
         order = SignalEvent(id, symbol, dtime, 'SHORT',
                             quantity=quantity, strength=strength, price=price)
-        self.orders[symbol]['SSTP'].append(order)
+        self._orders[symbol]['SSTP'].append(order)
 
     def buy_limit(self, id, symbol, price, quantity, strength=1.0, dtime=None):
         """
@@ -225,7 +284,7 @@ class MT5Strategy(Strategy):
                 "The buy_limit price must be less than the current price.")
         order = SignalEvent(id, symbol, dtime, 'LONG',
                             quantity=quantity, strength=strength, price=price)
-        self.orders[symbol]['BLMT'].append(order)
+        self._orders[symbol]['BLMT'].append(order)
 
     def sell_limit(self, id, symbol, price, quantity, strength=1.0, dtime=None):
         """
@@ -239,7 +298,7 @@ class MT5Strategy(Strategy):
                 "The sell_limit price must be greater than the current price.")
         order = SignalEvent(id, symbol, dtime, 'SHORT',
                             quantity=quantity, strength=strength, price=price)
-        self.orders[symbol]['SLMT'].append(order)
+        self._orders[symbol]['SLMT'].append(order)
 
     def buy_stop_limit(self, id: int, symbol: str, price: float, stoplimit: float, 
                        quantity: int, strength: float=1.0, dtime: datetime | pd.Timestamp = None):
@@ -257,7 +316,7 @@ class MT5Strategy(Strategy):
                 f"The stop-limit price {stoplimit} must be greater than the price {price}.")
         order = SignalEvent(id, symbol, dtime, 'LONG',
                             quantity=quantity, strength=strength, price=price, stoplimit=stoplimit)
-        self.orders[symbol]['BSTPLMT'].append(order)
+        self._orders[symbol]['BSTPLMT'].append(order)
 
     def sell_stop_limit(self, id, symbol, price, stoplimit, quantity, strength=1.0, dtime=None):
         """
@@ -274,7 +333,7 @@ class MT5Strategy(Strategy):
                 f"The stop-limit price {stoplimit} must be less than the price {price}.")
         order = SignalEvent(id, symbol, dtime, 'SHORT',
                             quantity=quantity, strength=strength, price=price, stoplimit=stoplimit)
-        self.orders[symbol]['SSTPLMT'].append(order)
+        self._orders[symbol]['SSTPLMT'].append(order)
 
     def check_pending_orders(self):
         """
@@ -282,54 +341,54 @@ class MT5Strategy(Strategy):
         """
         for symbol in self.symbols:
             dtime = self.data.get_latest_bar_datetime(symbol)
-            for order in self.orders[symbol]['BLMT'].copy():
+            for order in self._orders[symbol]['BLMT'].copy():
                 if self.data.get_latest_bar_value(symbol, 'close') <= order.price:
-                    self.buy(order.strategy_id, symbol,
+                    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)
-            for order in self.orders[symbol]['SLMT'].copy():
+                    self._orders[symbol]['BLMT'].remove(order)
+            for order in self._orders[symbol]['SLMT'].copy():
                 if self.data.get_latest_bar_value(symbol, 'close') >= order.price:
-                    self.sell(order.strategy_id, symbol,
+                    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)
-            for order in self.orders[symbol]['BSTP'].copy():
+                    self._orders[symbol]['SLMT'].remove(order)
+            for order in self._orders[symbol]['BSTP'].copy():
                 if self.data.get_latest_bar_value(symbol, 'close') >= order.price:
-                    self.buy(order.strategy_id, symbol,
+                    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)
-            for order in self.orders[symbol]['SSTP'].copy():
+                    self._orders[symbol]['BSTP'].remove(order)
+            for order in self._orders[symbol]['SSTP'].copy():
                 if self.data.get_latest_bar_value(symbol, 'close') <= order.price:
-                    self.sell(order.strategy_id, symbol,
+                    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)
-            for order in self.orders[symbol]['BSTPLMT'].copy():
+                    self._orders[symbol]['SSTP'].remove(order)
+            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)
-            for order in self.orders[symbol]['SSTPLMT'].copy():
+                    self._orders[symbol]['BSTPLMT'].remove(order)
+            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)
+                    self._orders[symbol]['SSTPLMT'].remove(order)
 
     def get_asset_values(self,
                           symbol_list: List[str],

bbstrader/metatrader/rates.py

@@ -178,8 +178,10 @@ class Rates(object):
         return TIMEFRAMES[time_frame]
 
     def _fetch_data(
-        self, start: Union[int, datetime , pd.Timestamp],
-        count: Union[int, datetime, pd.Timestamp], lower_colnames=False, utc=False,
+        self, 
+        start: Union[int, datetime, pd.Timestamp],
+        count: Union[int, datetime, pd.Timestamp], 
+        lower_colnames=False, utc=False,
     ) -> Union[pd.DataFrame, None]:
         """Fetches data from MT5 and returns a DataFrame or None."""
         try:
@@ -187,6 +189,13 @@ class Rates(object):
                 rates = Mt5.copy_rates_from_pos(
                     self.symbol, self.time_frame, start, count
                 )
+            elif ( 
+                isinstance(start, (datetime, pd.Timestamp)) and 
+                isinstance(count, int)
+                ):
+                rates = Mt5.copy_rates_from(
+                    self.symbol, self.time_frame, start, count
+                )
             elif (
                 isinstance(start, (datetime, pd.Timestamp)) and 
                 isinstance(count, (datetime, pd.Timestamp))
@@ -320,6 +329,35 @@ class Rates(object):
             return self._filter_data(df, fill_na=fill_na)
         return df
     
+    def get_rates_from(self, date_from: datetime | pd.Timestamp, count: int=MAX_BARS,
+                       filter=False, fill_na=False, lower_colnames=False, utc=False) -> Union[pd.DataFrame, None]:
+        """
+        Retrieves historical data within a specified date range.
+
+        Args:
+            date_from : Starting date for data retrieval.
+                The data will be retrieved from this date going to the past.
+            
+            count : Number of bars to retrieve.
+            
+            filter : See `Rates.get_historical_data` for more details.
+            fill_na : See `Rates.get_historical_data` for more details.
+            lower_colnames : If True, the column names will be converted to lowercase.
+            utc (bool, optional): If True, the data will be in UTC timezone.
+                Defaults to False.
+
+        Returns:
+            Union[pd.DataFrame, None]: A DataFrame containing historical
+            data if successful, otherwise None.
+        """
+        utc = self._check_filter(filter, utc)
+        df = self._fetch_data(date_from, count, lower_colnames=lower_colnames, utc=utc)
+        if df is None:
+            return None
+        if filter:
+            return self._filter_data(df, fill_na=fill_na)
+        return df
+
     @property
     def open(self):
         return self.__data['Open']
@@ -459,4 +497,14 @@ def get_data_from_pos(symbol, time_frame, start_pos=0, fill_na=False,
     rates = Rates(symbol, time_frame, start_pos, count, session_duration)
     data = rates.get_rates_from_pos(filter=filter, fill_na=fill_na,
                                     lower_colnames=lower_colnames, utc=utc)
+    return data
+
+def get_data_from_date(symbol, time_frame, date_from, count=MAX_BARS, fill_na=False, 
+                  lower_colnames=False, utc=False, filter=False):
+    """Get historical data from a specific date.
+    See `Rates.get_rates_from` for more details.
+    """
+    rates = Rates(symbol, time_frame)
+    data = rates.get_rates_from(date_from, count, filter=filter, fill_na=fill_na,
+                                lower_colnames=lower_colnames, utc=utc)
     return data

bbstrader/metatrader/trade.py

@@ -838,14 +838,16 @@ class Trade(RiskManagement):
         elif account and id is not None:
             # All open positions for a specific strategy or expert no matter the symbol
             positions = self.get_positions()
-            positions = [position for position in positions if position.magic == id]
+            if positions is not None:
+                positions = [position for position in positions if position.magic == id]
         elif not account and id is None:
             # All open positions for the current symbol no matter the strategy or expert
             positions = self.get_positions(symbol=self.symbol)
         elif not account and id is not None:
             # All open positions for the current symbol and a specific strategy or expert
             positions = self.get_positions(symbol=self.symbol)
-            positions = [position for position in positions if position.magic == id]
+            if positions is not None:
+                positions = [position for position in positions if position.magic == id]
         profit = 0.0
         balance = self.get_account_info().balance
         target = round((balance * self.target)/100, 2)
@@ -1026,8 +1028,9 @@ class Trade(RiskManagement):
                 result.retcode, display=True, add_msg=f"{e}{addtionnal}")
         if result.retcode != Mt5.TRADE_RETCODE_DONE:
             msg = trade_retcode_message(result.retcode)
-            self.logger.error(
-                f"Break-Even Order Request, Position: #{tiket}, RETCODE={result.retcode}: {msg}{addtionnal}")
+            if result.retcode != Mt5.TRADE_RETCODE_NO_CHANGES:
+                self.logger.error(
+                    f"Break-Even Order Request, Position: #{tiket}, RETCODE={result.retcode}: {msg}{addtionnal}")
             tries = 0
             while result.retcode != Mt5.TRADE_RETCODE_DONE and tries < 10:
                 if result.retcode == Mt5.TRADE_RETCODE_NO_CHANGES:

bbstrader/models/optimization.py

@@ -0,0 +1,170 @@
+import numpy as np
+import pandas as pd
+from pypfopt import risk_models
+from pypfopt import expected_returns
+from pypfopt.efficient_frontier import EfficientFrontier
+from pypfopt.hierarchical_portfolio import HRPOpt
+import warnings
+
+def markowitz_weights(prices=None, freq=252):
+    """
+    Calculates optimal portfolio weights using Markowitz's mean-variance optimization (Max Sharpe Ratio) with multiple solvers.
+
+    Parameters:
+    ----------
+    prices : pd.DataFrame, optional
+        Price data for assets, where rows represent time periods and columns represent assets.
+    freq : int, optional
+        Frequency of the data, such as 252 for daily returns in a year (default is 252).
+
+    Returns:
+    -------
+    dict
+        Dictionary containing the optimal asset weights for maximizing the Sharpe ratio, normalized to sum to 1.
+
+    Notes:
+    -----
+    This function attempts to maximize the Sharpe ratio by iterating through various solvers ('SCS', 'ECOS', 'OSQP') 
+    from the PyPortfolioOpt library. If a solver fails, it proceeds to the next one. If none succeed, an error message 
+    is printed for each solver that fails.
+
+    This function is useful for portfolio with a small number of assets, as it may not scale well for large portfolios.
+    
+    Raises:
+    ------
+    Exception
+        If all solvers fail, each will print an exception error message during runtime.
+    """
+    returns = expected_returns.mean_historical_return(prices, frequency=freq)
+    cov = risk_models.sample_cov(prices, frequency=freq)
+
+    # Try different solvers to maximize Sharpe ratio
+    for solver in ['SCS', 'ECOS', 'OSQP']:
+        ef = EfficientFrontier(expected_returns=returns, 
+                               cov_matrix=cov, 
+                               weight_bounds=(0, 1),
+                               solver=solver)
+        try:
+            weights = ef.max_sharpe()
+            return ef.clean_weights()
+        except Exception as e:
+            print(f"Solver {solver} failed with error: {e}")
+
+def hierarchical_risk_parity(prices=None, returns=None, freq=252):
+    """
+    Computes asset weights using Hierarchical Risk Parity (HRP) for risk-averse portfolio allocation.
+
+    Parameters:
+    ----------
+    prices : pd.DataFrame, optional
+        Price data for assets; if provided, daily returns will be calculated.
+    returns : pd.DataFrame, optional
+        Daily returns for assets. One of `prices` or `returns` must be provided.
+    freq : int, optional
+        Number of days to consider in calculating portfolio weights (default is 252).
+
+    Returns:
+    -------
+    dict
+        Optimized asset weights using the HRP method, with asset weights summing to 1.
+
+    Raises:
+    ------
+    ValueError
+        If neither `prices` nor `returns` are provided.
+
+    Notes:
+    -----
+    Hierarchical Risk Parity is particularly useful for portfolios with a large number of assets, 
+    as it mitigates issues of multicollinearity and estimation errors in covariance matrices by 
+    using hierarchical clustering.
+    """
+    warnings.filterwarnings("ignore")
+    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()
+    # Remove duplicate columns and index
+    returns = returns.loc[:, ~returns.columns.duplicated()]
+    returns = returns.loc[~returns.index.duplicated(keep='first')]
+    hrp = HRPOpt(returns=returns.iloc[-freq:])
+    return hrp.optimize()
+
+def equal_weighted(prices=None, returns=None, round_digits=5):
+    """
+    Generates an equal-weighted portfolio by assigning an equal proportion to each asset.
+
+    Parameters:
+    ----------
+    prices : pd.DataFrame, optional
+        Price data for assets, where each column represents an asset.
+    returns : pd.DataFrame, optional
+        Return data for assets. One of `prices` or `returns` must be provided.
+    round_digits : int, optional
+        Number of decimal places to round each weight to (default is 5).
+
+    Returns:
+    -------
+    dict
+        Dictionary with equal weights assigned to each asset, summing to 1.
+
+    Raises:
+    ------
+    ValueError
+        If neither `prices` nor `returns` are provided.
+
+    Notes:
+    -----
+    Equal weighting is a simple allocation method that assumes equal importance across all assets, 
+    useful as a baseline model and when no strong views exist on asset return expectations or risk.
+    """
+    if returns is None and prices is None:
+        raise ValueError("Either prices or returns must be provided")
+    if returns is None:
+        n = len(prices.columns)
+        columns = prices.columns
+    else:
+        n = len(returns.columns)
+        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'):
+    """
+    Selects an optimization method to calculate portfolio weights based on user preference.
+
+    Parameters:
+    ----------
+    prices : pd.DataFrame, optional
+        Price data for assets, required for certain methods.
+    returns : pd.DataFrame, optional
+        Returns data for assets, an alternative input for certain methods.
+    freq : int, optional
+        Number of days for calculating portfolio weights, such as 252 for a year's worth of daily returns (default is 252).
+    method : str, optional
+        Optimization method to use ('markowitz', 'hrp', or 'equal') (default is 'markowitz').
+
+    Returns:
+    -------
+    dict
+        Dictionary containing optimized asset weights based on the chosen method.
+
+    Raises:
+    ------
+    ValueError
+        If an unknown optimization method is specified.
+
+    Notes:
+    -----
+    This function integrates different optimization methods:
+    - 'markowitz': mean-variance optimization with max Sharpe ratio
+    - 'hrp': Hierarchical Risk Parity, for risk-based clustering of assets
+    - 'equal': Equal weighting across all assets
+    """
+    if method == 'markowitz':
+        return markowitz_weights(prices=prices, freq=freq)
+    elif method == 'hrp':
+        return hierarchical_risk_parity(prices=prices, returns=returns, freq=freq)
+    elif method == 'equal':
+        return equal_weighted(prices=prices, returns=returns)
+    else:
+        raise ValueError(f"Unknown method: {method}")

bbstrader/models/portfolios.py

@@ -0,0 +1,202 @@
+import numpy as np
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+from sklearn.decomposition import PCA
+from sklearn.preprocessing import scale
+from bbstrader.models.optimization import (
+    markowitz_weights, 
+    hierarchical_risk_parity, 
+    equal_weighted
+)
+
+
+class EigenPortfolios(object):
+    """
+    The `EigenPortfolios` class applies Principal Component Analysis (PCA) to a covariance matrix of normalized asset returns 
+    to derive portfolios (eigenportfolios) that capture distinct risk factors in the asset returns. Each eigenportfolio 
+    represents a principal component of the return covariance matrix, ordered by the magnitude of its eigenvalue. These 
+    portfolios capture most of the variance in asset returns and are mutually uncorrelated.
+    
+    """
+    def __init__(self):
+        self.returns = None
+        self.n_portfolios = None
+        self._portfolios = None
+        self._fit_called = False
+
+    def get_portfolios(self) -> pd.DataFrame:
+        """
+        Returns the computed eigenportfolios (weights of assets in each portfolio).
+        
+        Returns:
+        -------
+        pd.DataFrame
+            DataFrame containing eigenportfolio weights for each asset.
+        
+        Raises:
+        ------
+        ValueError
+            If `fit()` has not been called before retrieving portfolios.
+        """
+        if not self._fit_called:
+            raise ValueError("fit() must be called first")
+        return self._portfolios
+
+    def fit(self, returns: pd.DataFrame, n_portfolios: int=4) -> pd.DataFrame:
+        """
+        Computes the eigenportfolios based on PCA of the asset returns' covariance matrix.
+        
+        Parameters:
+        ----------
+        returns : pd.DataFrame
+            Historical returns of assets to be used for PCA.
+        n_portfolios : int, optional
+            Number of eigenportfolios to compute (default is 4).
+        
+        Returns:
+        -------
+        pd.DataFrame
+            DataFrame containing normalized weights for each eigenportfolio.
+
+        Notes:
+        -----
+        This method performs winsorization and normalization on returns to reduce the impact of outliers 
+        and achieve zero mean and unit variance. It uses the first `n_portfolios` principal components 
+        as portfolio weights.
+        """
+        # Winsorize and normalize the returns
+        normed_returns = scale(returns
+                            .clip(lower=returns.quantile(q=.025), 
+                                    upper=returns.quantile(q=.975), 
+                                    axis=1)
+                            .apply(lambda x: x.sub(x.mean()).div(x.std())))
+        returns = returns.dropna(thresh=int(normed_returns.shape[0] * .95), axis=1)
+        returns = returns.dropna(thresh=int(normed_returns.shape[1] * .95))
+
+        cov = returns.cov()
+        cov.columns = cov.columns.astype(str)
+        pca = PCA()
+        pca.fit(cov)
+
+        top_portfolios = pd.DataFrame(pca.components_[:n_portfolios], columns=cov.columns)
+        eigen_portfolios = top_portfolios.div(top_portfolios.sum(axis=1), axis=0)
+        eigen_portfolios.index = [f"Portfolio {i}" for i in range(1, n_portfolios + 1)]
+        self._portfolios = eigen_portfolios
+        self.returns = returns
+        self.n_portfolios = n_portfolios
+        self._fit_called = True
+
+    def plot_weights(self):
+        """
+        Plots the weights of each asset in each eigenportfolio as bar charts.
+        
+        Notes:
+        -----
+        Each subplot represents one eigenportfolio, showing the contribution of each asset.
+        """
+        eigen_portfolios = self.get_portfolios()
+        n_cols = 2
+        n_rows = (self.n_portfolios + 1) // n_cols
+        figsize = (n_cols * 10, n_rows * 5)
+        axes = eigen_portfolios.T.plot.bar(subplots=True,
+                                           layout=(n_rows, n_cols),
+                                           figsize=figsize,
+                                           legend=False)
+        for ax in axes.flatten():
+            ax.set_ylabel('Portfolio Weight')
+            ax.set_xlabel('')
+        
+        sns.despine()
+        plt.tight_layout()
+        plt.show()
+
+    def plot_performance(self):
+        """
+        Plots the cumulative returns of each eigenportfolio over time.
+        
+        Notes:
+        -----
+        This method calculates the historical cumulative performance of each eigenportfolio 
+        by weighting asset returns according to eigenportfolio weights.
+        """
+        eigen_portfolios = self.get_portfolios()
+        returns = self.returns.copy()
+        
+        n_cols = 2
+        n_rows = (self.n_portfolios + 1 + n_cols - 1) // n_cols
+        figsize = (n_cols * 10, n_rows * 5)
+        fig, axes = plt.subplots(nrows=n_rows, ncols=n_cols,
+                                 figsize=figsize, sharex=True)
+        axes = axes.flatten()
+        returns.mean(1).add(1).cumprod().sub(1).plot(title='The Market', ax=axes[0])
+        
+        for i in range(self.n_portfolios):
+            rc = returns.mul(eigen_portfolios.iloc[i]).sum(1).add(1).cumprod().sub(1)
+            rc.plot(title=f'Portfolio {i+1}', ax=axes[i + 1], lw=1, rot=0)
+
+        for j in range(self.n_portfolios + 1, len(axes)):
+            fig.delaxes(axes[j])
+
+        for i in range(self.n_portfolios + 1):
+            axes[i].set_xlabel('')
+        
+        sns.despine()
+        fig.tight_layout()
+        plt.show()
+    
+    def optimize(self, portfolio: int = 1, optimizer: str = 'hrp', prices=None, freq=252, plot=True):
+        """
+        Optimizes the chosen eigenportfolio based on a specified optimization method.
+        
+        Parameters:
+        ----------
+        portfolio : int, optional
+            Index of the eigenportfolio to optimize (default is 1).
+        optimizer : str, optional
+            Optimization method: 'markowitz', 'hrp' (Hierarchical Risk Parity), or 'equal' (default is 'hrp').
+        prices : pd.DataFrame, optional
+            Asset prices used for Markowitz optimization (required if optimizer is 'markowitz').
+        freq : int, optional
+            Frequency of returns (e.g., 252 for daily returns).
+        plot : bool, optional
+            Whether to plot the performance of the optimized portfolio (default is True).
+        
+        Returns:
+        -------
+        dict
+            Dictionary of optimized asset weights.
+        
+        Raises:
+        ------
+        ValueError
+            If an unknown optimizer is specified, or if prices are not provided when using Markowitz optimization.
+        
+        Notes:
+        -----
+        The optimization method varies based on risk-return assumptions, with options for traditional Markowitz optimization,
+        Hierarchical Risk Parity, or equal weighting.
+        """
+        portfolio = self.get_portfolios().iloc[portfolio - 1]
+        returns = self.returns.loc[:, portfolio.index]
+        returns =  returns.loc[:, ~returns.columns.duplicated()]
+        returns = returns.loc[~returns.index.duplicated(keep='first')]
+        if optimizer == 'markowitz':
+            if prices is None:
+                raise ValueError("prices must be provided for markowitz optimization")
+            prices = prices.loc[:, returns.columns]
+            weights = markowitz_weights(prices=prices, freq=freq)
+        elif optimizer == 'hrp':
+            weights = hierarchical_risk_parity(returns=returns, freq=freq)
+        elif optimizer == 'equal':
+            weights = equal_weighted(returns=returns)
+        else:
+            raise ValueError(f"Unknown optimizer: {optimizer}")
+        if plot:
+            # plot the optimized potfolio performance
+            returns = returns.filter(weights.keys())
+            rc = returns.mul(weights).sum(1).add(1).cumprod().sub(1)
+            rc.plot(title=f'Optimized {portfolio.name}', lw=1, rot=0)
+            sns.despine()
+            plt.show()
+        return weights

bbstrader/trading/execution.py

@@ -90,7 +90,7 @@ def _mt5_execution(
         bot_token = kwargs.get('bot_token')
         chat_id   = kwargs.get('chat_id')
 
-    def _send_notification(self, signal):
+    def _send_notification(signal):
         send_message(message=signal, notify_me=notify, 
                     telegram=telegram, token=bot_token, chat_id=chat_id)
         
@@ -104,8 +104,6 @@ def _mt5_execution(
         if not mm:
             return
         if buys is not None or sells is not None:
-            logger.info(
-                f"Checking for Break even, SYMBOL={symbol}...STRATEGY={STRATEGY}")
             trades_instances[symbol].break_even(
                 mm=mm, trail=trail, stop_trail=stop_trail, 
                 trail_after_points=trail_after_points, be_plus_points=be_plus_points)
@@ -119,10 +117,10 @@ def _mt5_execution(
         check_mt5_connection()
         strategy: MT5Strategy = strategy_cls(symbol_list=symbols, mode='live', **kwargs)
     except Exception as e:
-        logger.error(f"Error initializing strategy, {e}, STRATEGY={STRATEGY}")
+        logger.error(f"Initializing strategy, {e}, STRATEGY={STRATEGY}")
         return
     logger.info(
-        f'Running {STRATEGY} Strategy on {symbols} in {time_frame} Interval ...')
+        f'Running {STRATEGY} Strategy in {time_frame} Interval ...')
     
     while True:
         try:
@@ -132,7 +130,9 @@ def _mt5_execution(
             time.sleep(0.5)
             positions_orders = {}
             for type in POSITIONS_TYPES + ORDERS_TYPES:
+                positions_orders[type] = {}
                 for symbol in symbols:
+                    positions_orders[type][symbol] = None
                     func = getattr(trades_instances[symbol], f"get_current_{type}")
                     positions_orders[type][symbol] = func()
             buys = positions_orders['buys']
@@ -154,7 +154,7 @@ def _mt5_execution(
             }
 
         except Exception as e:
-            logger.error(f"{e}, STRATEGY={STRATEGY}")
+            logger.error(f"Handling Positions and Orders, {e}, STRATEGY={STRATEGY}")
             continue
         time.sleep(0.5)
         try:
@@ -183,7 +183,8 @@ def _mt5_execution(
                         signal = 'SMKT' if signal == 'SHORT' else signal
                         info = f"SIGNAL = {signal}, SYMBOL={trade.symbol}, STRATEGY={STRATEGY}"
                         msg = f"Sending {signal} Order ... SYMBOL={trade.symbol}, STRATEGY={STRATEGY}"
-                        logger.info(info)
+                        if signal not in EXIT_SIGNAL_ACTIONS:
+                            logger.info(info)
                         if signal in EXIT_SIGNAL_ACTIONS:
                             for exit_signal, actions in EXIT_SIGNAL_ACTIONS.items():
                                 for position_type, order_type in actions.items():
@@ -235,13 +236,15 @@ def _mt5_execution(
                         elif signal in SELLS and short_market[symbol]:
                             logger.info(riskmsg)
                             check(buys[symbol], sells[symbol], symbol)
+                    else:
+                        check(buys[symbol], sells[symbol], symbol)
                 else:
                     logger.info(
                         f"Not trading Time !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
                     check(buys[symbol], sells[symbol], symbol)
 
             except Exception as e:
-                logger.error(f"{e}, SYMBOL={symbol}, STRATEGY={STRATEGY}")
+                logger.error(f"Handling Signals {e}, SYMBOL={symbol}, STRATEGY={STRATEGY}")
                 continue
         time.sleep((60 * iter_time) - 1.0)
         if iter_time == 1:
@@ -253,7 +256,6 @@ def _mt5_execution(
                 f"iter_time must be a multiple of the {time_frame} !!!"
                 f"(e.g; if time_frame is 15m, iter_time must be 1.5, 3, 3, 15 etc)"
             )
-        print()
         try:
             FRIDAY = 'friday'
             check_mt5_connection()

{bbstrader-0.1.91.dist-info → bbstrader-0.1.92.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bbstrader
-Version: 0.1.91
+Version: 0.1.92
 Summary: Simplified Investment & Trading Toolkit
 Home-page: https://github.com/bbalouki/bbstrader
 Download-URL: https://pypi.org/project/bbstrader/
@@ -46,6 +46,7 @@ Requires-Dist: tqdm
 Requires-Dist: scikit-learn
 Requires-Dist: notify-py
 Requires-Dist: python-telegram-bot
+Requires-Dist: pyportfolioopt
 Provides-Extra: mt5
 Requires-Dist: MetaTrader5 ; extra == 'mt5'
 

{bbstrader-0.1.91.dist-info → bbstrader-0.1.92.dist-info}/RECORD

@@ -2,30 +2,31 @@ bbstrader/__ini__.py,sha256=rCTy-3g2RlDAgIZ7cSET9-I74MwuCXpp-xGVTFS8NNc,482
 bbstrader/config.py,sha256=_AD_Cd-w5zyabm1CBPNGhzcZuSjThB7jyzTcjbrIlUQ,3618
 bbstrader/tseries.py,sha256=qJKLxHnPOjB7dXon-ITK7vU1fAuvl8evzET6lSSnijQ,53572
 bbstrader/btengine/__init__.py,sha256=OaXZTjgDwqWrjPq-CNE4kJkmriKXt9t5pIghW1MDTeo,2911
-bbstrader/btengine/backtest.py,sha256=HDuCNUETLUBZ0R8AVLeT5gZVVk8UQ6oeReUtDvUFhIk,13681
-bbstrader/btengine/data.py,sha256=zeF3O7_vPT3NvAxlAcUS9OoxF09XhypDhGiVRml3U1A,17622
-bbstrader/btengine/event.py,sha256=DQTmUQ4l4yZgL47hW1dGv__CecNF-rDqsyFst5kCQvA,8453
-bbstrader/btengine/execution.py,sha256=gijnRvknNi921TjtF9wSyBG_nI0e2cda2NKIm3LJh1k,10222
+bbstrader/btengine/backtest.py,sha256=bgQNiS_kb1zWyX_8_OIDGTBlHGC5pw7ZMIQ5csYDahA,14115
+bbstrader/btengine/data.py,sha256=A6jUqDnjl-w1OSzbLLPfS1WfJ8Se25AqigJs9pbe0wc,17966
+bbstrader/btengine/event.py,sha256=zF_ST4tcjV5uJJVV1IbRXQgCLbca2R2fmE7A2MaIno4,8748
+bbstrader/btengine/execution.py,sha256=i-vI9LGqVtEIKfH_T5Airv-gI4t1X75CfuFIuQdogkA,10187
 bbstrader/btengine/performance.py,sha256=bKwj1_CSygvggLKTXPASp2eWhDdwyCf06ayUaXwdh4E,10655
-bbstrader/btengine/portfolio.py,sha256=uf1fx0RuTTQNNxiYmCYW_sh6sBWbtNq4uIRusKA5MdY,15399
-bbstrader/btengine/strategy.py,sha256=ktTzlJzSTo9zhZsILwj2vtPHjAkI-aSnKA8PcT3nF6Y,23206
+bbstrader/btengine/portfolio.py,sha256=9Jw0UA2gPu-YkUNenoMSHt8t-axtbl6veWXgcRMTQ14,16074
+bbstrader/btengine/strategy.py,sha256=w5vwlpJNIVjslaHprWDr-3j-JJPiO1EvqeyrJmorByE,25721
 bbstrader/metatrader/__init__.py,sha256=OLVOB_EieEb1P72I8V4Vem8kQWJ__D_L3c_wfwqY-9k,211
 bbstrader/metatrader/account.py,sha256=hVH83vnAdfMOzUsF9PiWelqxa7HaLSTpCVlUEePnSZg,53912
-bbstrader/metatrader/rates.py,sha256=xWTsM8PMPGdgwoPXcIRvHpJ1FKRIXHJcn4qrgmA7XRg,18737
+bbstrader/metatrader/rates.py,sha256=1dJHbVqoT41m3EhF0wRe7dSGe5Kf3o5Maskkw-i5qsQ,20810
 bbstrader/metatrader/risk.py,sha256=8FcLY8pgV8_rxAcjx179sdqaMu66wl-fDFPZvdihfUw,25953
-bbstrader/metatrader/trade.py,sha256=68hYIA01OPApRgGNdS1YFgM83ZemkCmv6mTXOCS_kWc,70052
+bbstrader/metatrader/trade.py,sha256=uigDah9n_rVJiwSslTAArLP94sde1dxYyGyRVIPPgb4,70210
 bbstrader/metatrader/utils.py,sha256=BTaZun4DKWpCxBBzY0SLQqqz7n_7F_R1F59APfyaa3E,17666
 bbstrader/models/__init__.py,sha256=6tAj9V9vgwesgPVMKznwRB3k8-Ec8Q73Di5p2UO0qlA,274
 bbstrader/models/factors.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bbstrader/models/ml.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bbstrader/models/optimization.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bbstrader/models/optimization.py,sha256=0ZOCinveMCSxpL4gTBO5lbZ6jb1HXp0CeIjO-_fNGro,6521
+bbstrader/models/portfolios.py,sha256=TyLcYwxW86t1qH6YS5xBaiKB9Owezq3ovffjR0Othlw,8184
 bbstrader/models/risk.py,sha256=Pm_WoGI-vtPW75fwo_7ptF2Br-xQYBwrAAOIgqDQmy8,15120
 bbstrader/trading/__init__.py,sha256=3CCzV5rQbH8NthjDJhD0_2FABvpiCmkeC9cVeoW7bi4,438
-bbstrader/trading/execution.py,sha256=5mGanLIB1nPfbXA9r_uKGDCkcV-ilVgZmssF7Oh4SeI,25186
+bbstrader/trading/execution.py,sha256=Ze_YFrdgU9mRZsS4J08lZNE77HBwxrun5rdqHkS4dzE,25348
 bbstrader/trading/scripts.py,sha256=rQmnG_4F_MuUEc96RXpAQT4kXrC-FkscsgHKgDAR_-Y,1902
 bbstrader/trading/strategies.py,sha256=ztKNL4Nmlb-4N8_cq0OJyn3E2cRcdKdKu3FeTbZrHsU,36402
-bbstrader-0.1.91.dist-info/LICENSE,sha256=1EudjwwP2oTJy8Vh0e-Kzv8VZZU95y-t6c3DYhR51uc,1115
-bbstrader-0.1.91.dist-info/METADATA,sha256=ZwHR-DYmIhULp_5dh48oQ_lGR0VYQnkGG8GcaQe1KP4,9901
-bbstrader-0.1.91.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-bbstrader-0.1.91.dist-info/top_level.txt,sha256=Wwj322jZmxGZ6gD_TdaPiPLjED5ReObm5omerwlmZIg,10
-bbstrader-0.1.91.dist-info/RECORD,,
+bbstrader-0.1.92.dist-info/LICENSE,sha256=1EudjwwP2oTJy8Vh0e-Kzv8VZZU95y-t6c3DYhR51uc,1115
+bbstrader-0.1.92.dist-info/METADATA,sha256=LZdzZUHKait-lIvprJ85AxfRuHp8VE5QPS69y8uZIIs,9932
+bbstrader-0.1.92.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+bbstrader-0.1.92.dist-info/top_level.txt,sha256=Wwj322jZmxGZ6gD_TdaPiPLjED5ReObm5omerwlmZIg,10
+bbstrader-0.1.92.dist-info/RECORD,,