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

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/metatrader/account.py

@@ -125,9 +125,57 @@ AMG_EXCHANGES = {
     'XSWX': r"Switzerland.*\(SWX\)"
 }
 
-def check_mt5_connection():
+def check_mt5_connection(**kwargs):
+    """
+    Initialize the connection to the MetaTrader 5 terminal.
+
+    Args:
+        path (str, optional): The path to the MetaTrader 5 terminal executable file. 
+            Defaults to None (e.g., "C:\\Program Files\\MetaTrader 5\\terminal64.exe").
+        login (int, optional): The login ID of the trading account. Defaults to None.
+        password (str, optional): The password of the trading account. Defaults to None.
+        server (str, optional): The name of the trade server to which the client terminal is connected. 
+            Defaults to None.
+        timeout (int, optional): Connection timeout in milliseconds. Defaults to 60_000.
+        portable (bool, optional): If True, the portable mode of the terminal is used. 
+            Defaults to False (See https://www.metatrader5.com/en/terminal/help/start_advanced/start#portable).
+    
+    Notes:
+        If you want to lunch multiple terminal instances:
+        - Follow these instructions to lunch each terminal in portable mode first:
+            https://www.metatrader5.com/en/terminal/help/start_advanced/start#configuration_file
+    """
+    path     = kwargs.get('path', None)
+    login    = kwargs.get('login', None)
+    password = kwargs.get('password', None)
+    server   = kwargs.get('server', None)
+    timeout  = kwargs.get('timeout', 60_000)
+    portable = kwargs.get('portable', False)
+
+    if path is None and (login or password or server):
+        raise ValueError(
+            f"You must provide a path to the terminal executable file"
+            f"when providing login, password or server"
+        )
     try:
-        init = mt5.initialize()
+        if path is not None:
+            if (
+                login is not None and 
+                password is not None and 
+                server is not None
+            ):
+                init = mt5.initialize(
+                    path=path,
+                    login=login,
+                    password=password,
+                    server=server,
+                    timeout=timeout,
+                    portable=portable
+                )
+            else:
+                init = mt5.initialize(path=path)
+        else:
+            init = mt5.initialize()
         if not init:
             raise_mt5_error(INIT_MSG)
     except Exception:
@@ -135,9 +183,9 @@ def check_mt5_connection():
 
 
 class Broker(object):
-    def __init__(self, name: str=None):
+    def __init__(self, name: str=None, **kwargs):
         if name is None:
-            check_mt5_connection()
+            check_mt5_connection(**kwargs)
             self._name = mt5.account_info().company
         else:
             self._name = name
@@ -157,8 +205,8 @@ class Broker(object):
 
 
 class AdmiralMarktsGroup(Broker):
-    def __init__(self):
-        super().__init__("Admirals Group AS")
+    def __init__(self, **kwargs):
+        super().__init__("Admirals Group AS", **kwargs)
     
     @property
     def timezone(self) -> str:
@@ -166,8 +214,8 @@ class AdmiralMarktsGroup(Broker):
 
 
 class JustGlobalMarkets(Broker):
-    def __init__(self):
-        super().__init__("Just Global Markets Ltd.")
+    def __init__(self, **kwargs):
+        super().__init__("Just Global Markets Ltd.", **kwargs)
 
     @property
     def timezone(self) -> str:
@@ -175,8 +223,8 @@ class JustGlobalMarkets(Broker):
 
 
 class FTMO(Broker):
-    def __init__(self):
-        super().__init__("FTMO S.R.O.")
+    def __init__(self, **kwargs):
+        super().__init__("FTMO S.R.O.", **kwargs)
     
     @property
     def timezone(self) -> str:
@@ -230,8 +278,14 @@ class Account(object):
         >>> trade_history = account.get_trade_history(from_date, to_date)
     """
 
-    def __init__(self):
-        check_mt5_connection()
+    def __init__(self, **kwargs):
+        """
+        Initialize the Account class.
+
+        See `bbstrader.metatrader.account.check_mt5_connection()` for more details on how to connect to MT5 terminal.
+
+        """
+        check_mt5_connection(**kwargs)
         self._check_brokers()
 
     def _check_brokers(self):
@@ -688,7 +742,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/metatrader/rates.py

@@ -82,6 +82,8 @@ class Rates(object):
         2. The `open, high, low, close, adjclose, returns,
         volume` properties returns data in  Broker's timezone by default.
 
+        See `bbstrader.metatrader.account.check_mt5_connection()` for more details on how to connect to MT5 terminal.
+
     Example:
         >>> rates = Rates("EURUSD", "1h")
         >>> df = rates.get_historical_data(
@@ -94,17 +96,18 @@ class Rates(object):
     def __init__(
         self,
         symbol: str,
-        time_frame: TimeFrame = 'D1',
+        timeframe: TimeFrame = 'D1',
         start_pos: Union[int , str] = 0,
         count: Optional[int] = MAX_BARS,
-        session_duration: Optional[float] = None
+        session_duration: Optional[float] = None,
+        **kwargs
     ):
         """
         Initializes a new Rates instance.
 
         Args:
             symbol (str): Financial instrument symbol (e.g., "EURUSD").
-            time_frame (str): Timeframe string (e.g., "D1", "1h", "5m").
+            timeframe (str): Timeframe string (e.g., "D1", "1h", "5m").
             start_pos (int, | str): Starting index (int)  or date (str) for data retrieval.
             count (int, optional): Number of bars to retrieve default is
                 the maximum bars availble in the MT5 terminal.
@@ -118,16 +121,17 @@ class Rates(object):
             For `session_duration` check your broker symbols details
         """
         self.symbol = symbol
-        self.time_frame = self._validate_time_frame(time_frame)
+        tf = kwargs.get('time_frame')
+        self.time_frame = self._validate_time_frame(timeframe)
         self.sd = session_duration
-        self.start_pos = self._get_start_pos(start_pos, time_frame)
+        self.start_pos = self._get_start_pos(start_pos, timeframe)
         self.count = count
-        self._mt5_initialized()
-        self.__account = Account()
+        self._mt5_initialized(**kwargs)
+        self.__account = Account(**kwargs)
         self.__data = self.get_rates_from_pos()
 
-    def _mt5_initialized(self):
-        check_mt5_connection()
+    def _mt5_initialized(self, **kwargs):
+        check_mt5_connection(**kwargs)
     
     def _get_start_pos(self, index, time_frame):
         if isinstance(index, int):
@@ -471,13 +475,13 @@ class Rates(object):
             df.to_csv(f"{self.symbol}.csv")
         return df
 
-def download_historical_data(symbol, time_frame, date_from, 
+def download_historical_data(symbol, timeframe, date_from, 
                              date_to=pd.Timestamp.now(),lower_colnames=True, 
-                             utc=False, filter=False, fill_na=False, save_csv=False):
+                             utc=False, filter=False, fill_na=False, save_csv=False, **kwargs):
     """Download historical data from MetaTrader 5 terminal.
     See `Rates.get_historical_data` for more details.
     """
-    rates = Rates(symbol, time_frame)
+    rates = Rates(symbol, timeframe, **kwargs)
     data = rates.get_historical_data(
         date_from=date_from,
         date_to=date_to,
@@ -488,23 +492,23 @@ def download_historical_data(symbol, time_frame, date_from,
     )
     return data
 
-def get_data_from_pos(symbol, time_frame, start_pos=0, fill_na=False, 
+def get_data_from_pos(symbol, timeframe, start_pos=0, fill_na=False, 
                       count=MAX_BARS, lower_colnames=False, utc=False, filter=False,
-                        session_duration=23.0):
+                        session_duration=23.0, **kwargs):
     """Get historical data from a specific position.
     See `Rates.get_rates_from_pos` for more details.
     """
-    rates = Rates(symbol, time_frame, start_pos, count, session_duration)
+    rates = Rates(symbol, timeframe, start_pos, count, session_duration, **kwargs)
     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):
+def get_data_from_date(symbol, timeframe, date_from, count=MAX_BARS, fill_na=False, 
+                  lower_colnames=False, utc=False, filter=False, **kwargs):
     """Get historical data from a specific date.
     See `Rates.get_rates_from` for more details.
     """
-    rates = Rates(symbol, time_frame)
+    rates = Rates(symbol, timeframe, **kwargs)
     data = rates.get_rates_from(date_from, count, filter=filter, fill_na=fill_na,
                                 lower_colnames=lower_colnames, utc=utc)
     return data

bbstrader/metatrader/risk.py

@@ -118,8 +118,10 @@ class RiskManagement(Account):
             tp (int, optional): Take Profit in points, Must be a positive number.
             be (int, optional): Break Even in points, Must be a positive number.
             rr (float, optional): Risk reward ratio, Must be a positive number. Defaults to 1.5.
+        
+        See `bbstrader.metatrader.account.check_mt5_connection()` for more details on how to connect to MT5 terminal.
         """
-        super().__init__()
+        super().__init__(**kwargs)
 
         # Validation
         if daily_risk is not None and daily_risk < 0:
@@ -137,6 +139,7 @@ class RiskManagement(Account):
         if var_time_frame not in TIMEFRAMES:
             raise ValueError("Unsupported time frame {}".format(var_time_frame))
 
+        self.kwargs = kwargs
         self.symbol = symbol
         self.start_time = start_time
         self.finishing_time = finishing_time
@@ -156,6 +159,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"""
@@ -263,7 +282,7 @@ class RiskManagement(Account):
         tf_int = self._convert_time_frame(self._tf)
         interval = round((minutes / tf_int)  * 252)
 
-        rate = Rates(self.symbol, self._tf, 0, interval)
+        rate = Rates(self.symbol, self._tf, 0, interval, **self.kwargs)
         returns = rate.returns*100
         std = returns.std()
         point = self.get_symbol_info(self.symbol).point
@@ -317,7 +336,7 @@ class RiskManagement(Account):
         tf_int = self._convert_time_frame(tf)
         interval = round((minutes / tf_int)  * 252)
 
-        rate = Rates(self.symbol, tf, 0, interval)
+        rate = Rates(self.symbol, tf, 0, interval, **self.kwargs)
         returns = rate.returns*100
         p = self.get_account_info().margin_free
         mu = returns.mean()
@@ -437,14 +456,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