bbstrader 0.1.91__tar.gz → 0.1.92__tar.gz

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

@@ -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 → bbstrader-0.1.92}/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-0.1.91 → bbstrader-0.1.92}/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-0.1.91 → bbstrader-0.1.92}/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-0.1.91 → bbstrader-0.1.92}/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-0.1.91 → bbstrader-0.1.92}/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-0.1.91 → bbstrader-0.1.92}/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],