bbstrader 0.2.991__py3-none-any.whl → 0.3.0__py3-none-any.whl

bbstrader/metatrader/account.py

@@ -14,6 +14,7 @@ from bbstrader.metatrader.utils import (
     OrderCheckResult,
     OrderSentResult,
     SymbolInfo,
+    SymbolType,
     TerminalInfo,
     TickInfo,
     TradeDeal,
@@ -84,14 +85,14 @@ ftmo_url = _FTMO_URL_
 
 
 _SYMBOLS_TYPE_ = {
-    "ETF": r"\b(ETFs?)\b",
-    "BOND": r"\b(Treasuries?)\b",
-    "FX": r"\b(Forex|Exotics?)\b",
-    "FUT": r"\b(Futures?|Forwards)\b",
-    "STK": r"\b(Stocks?|Equities?|Shares?)\b",
-    "IDX": r"\b(?:Indices?|Cash|Index)\b(?!.*\\(?:UKOIL|USOIL))",
-    "COMD": r"\b(Commodity|Commodities?|Metals?|Agricultures?|Energies?|OIL|Oil|USOIL|UKOIL)\b",
-    "CRYPTO": r"\b(Cryptos?|Cryptocurrencies|Cryptocurrency)\b",
+    SymbolType.ETFs: r"\b(ETFs?)\b",
+    SymbolType.BONDS: r"\b(Treasuries?)\b",
+    SymbolType.FOREX: r"\b(Forex|Exotics?)\b",
+    SymbolType.FUTURES: r"\b(Futures?|Forwards)\b",
+    SymbolType.STOCKS: r"\b(Stocks?|Equities?|Shares?)\b",
+    SymbolType.INDICES: r"\b(?:Indices?|Cash|Index)\b(?!.*\\(?:UKOIL|USOIL))",
+    SymbolType.COMMODITIES: r"\b(Commodity|Commodities?|Metals?|Agricultures?|Energies?|OIL|Oil|USOIL|UKOIL)\b",
+    SymbolType.CRYPTO: r"\b(Cryptos?|Cryptocurrencies|Cryptocurrency)\b",
 }
 
 _COUNTRY_MAP_ = {
@@ -222,7 +223,7 @@ class Broker(object):
 
 class AdmiralMarktsGroup(Broker):
     def __init__(self, **kwargs):
-        super().__init__("Admirals Group AS", **kwargs)
+        super().__init__(__BROKERS__["AMG"], **kwargs)
 
     @property
     def timezone(self) -> str:
@@ -231,7 +232,7 @@ class AdmiralMarktsGroup(Broker):
 
 class JustGlobalMarkets(Broker):
     def __init__(self, **kwargs):
-        super().__init__("Just Global Markets Ltd.", **kwargs)
+        super().__init__(__BROKERS__["JGM"], **kwargs)
 
     @property
     def timezone(self) -> str:
@@ -240,7 +241,7 @@ class JustGlobalMarkets(Broker):
 
 class FTMO(Broker):
     def __init__(self, **kwargs):
-        super().__init__("FTMO S.R.O.", **kwargs)
+        super().__init__(__BROKERS__["FTMO"], **kwargs)
 
     @property
     def timezone(self) -> str:
@@ -249,7 +250,7 @@ class FTMO(Broker):
 
 class PepperstoneGroupLimited(Broker):
     def __init__(self, **kwargs):
-        super().__init__("Pepperstone Group Limited", **kwargs)
+        super().__init__(__BROKERS__["PGL"], **kwargs)
 
     @property
     def timezone(self) -> str:
@@ -316,6 +317,8 @@ class Account(object):
     def _check_brokers(self, **kwargs):
         if kwargs.get("copy", False):
             return
+        if kwargs.get("backtest", False):
+            return
         supported = BROKERS.copy()
         if self.broker not in supported.values():
             msg = (
@@ -574,7 +577,7 @@ class Account(object):
 
     def get_symbols(
         self,
-        symbol_type="ALL",
+        symbol_type: SymbolType | str = "ALL",
         check_etf=False,
         save=False,
         file_name="symbols",
@@ -585,16 +588,9 @@ class Account(object):
         Get all specified financial instruments from the MetaTrader 5 terminal.
 
         Args:
-            symbol_type (str) The category of instrument to get
+            symbol_type (SymbolType | str): The type of financial instruments to retrieve.
             - `ALL`: For all available symbols
-            - `STK`: Stocks (e.g., 'GOOGL')
-            - `ETF`: ETFs (e.g., 'QQQ')
-            - `IDX`: Indices (e.g., 'SP500')
-            - `FX`: Forex pairs (e.g., 'EURUSD')
-            - `COMD`: Commodities (e.g., 'CRUDOIL', 'GOLD')
-            - `FUT`: Futures (e.g., 'USTNote_U4'),
-            - `CRYPTO`: Cryptocurrencies (e.g., 'BTC', 'ETH')
-            - `BOND`: Bonds (e.g., 'USTN10YR')
+            - See `bbstrader.metatrader.utils.SymbolType` for more details.
 
             check_etf (bool): If True and symbol_type is 'etf', check if the
                 ETF description contains 'ETF'.
@@ -621,9 +617,21 @@ class Account(object):
         patterns = _SYMBOLS_TYPE_
 
         if symbol_type != "ALL":
-            if symbol_type not in patterns:
+            if not isinstance(symbol_type, SymbolType) or symbol_type not in patterns:
                 raise ValueError(f"Unsupported symbol type: {symbol_type}")
 
+        def check_etfs(info):
+            err_msg = (
+                f"{info.name} doesn't have 'ETF' in its description. "
+                "If this is intended, set check_etf=False."
+            )
+            if (
+                symbol_type == SymbolType.ETFs
+                and check_etf
+                and "ETF" not in info.description
+            ):
+                raise ValueError(err_msg)
+
         if save:
             max_lengh = max([len(s.name) for s in symbols])
             file_path = f"{file_name}.txt"
@@ -637,15 +645,7 @@ class Account(object):
                         pattern = re.compile(patterns[symbol_type])
                         match = re.search(pattern, info.path)
                         if match:
-                            if (
-                                symbol_type == "ETF"
-                                and check_etf
-                                and "ETF" not in info.description
-                            ):
-                                raise ValueError(
-                                    f"{info.name} doesn't have 'ETF' in its description. "
-                                    "If this is intended, set check_etf=False."
-                                )
+                            check_etfs(info)
                             self._write_symbol(file, info, include_desc, max_lengh)
                             symbol_list.append(s.name)
 
@@ -658,31 +658,16 @@ class Account(object):
                     pattern = re.compile(patterns[symbol_type])  # , re.IGNORECASE
                     match = re.search(pattern, info.path)
                     if match:
-                        if (
-                            symbol_type == "ETF"
-                            and check_etf
-                            and "ETF" not in info.description
-                        ):
-                            raise ValueError(
-                                f"{info.name} doesn't have 'ETF' in its description. "
-                                "If this is intended, set check_etf=False."
-                            )
+                        check_etfs(info)
                         symbol_list.append(s.name)
 
         # Print a summary of the retrieved symbols
         if display_total:
-            names = {
-                "ALL": "Symbols",
-                "STK": "Stocks",
-                "ETF": "ETFs",
-                "IDX": "Indices",
-                "FX": "Forex Paires",
-                "COMD": "Commodities",
-                "FUT": "Futures",
-                "CRYPTO": "Cryptos Assets",
-                "BOND": "Bonds",
-            }
-            print(f"Total {names[symbol_type]}: {len(symbol_list)}")
+            name = symbol_type if isinstance(symbol_type, str) else symbol_type.name
+            if symbol_type == "ALL":
+                print(f"Total number of symbols: {len(symbol_list)}")
+            else:
+                print(f"Total number of {name} symbols: {len(symbol_list)}")
 
         return symbol_list
 
@@ -694,9 +679,7 @@ class Account(object):
         else:
             file.write(info.name + "\n")
 
-    def get_symbol_type(
-        self, symbol: str
-    ) -> Literal["STK", "ETF", "IDX", "FX", "COMD", "FUT", "CRYPTO", "BOND", "unknown"]:
+    def get_symbol_type(self, symbol: str) -> SymbolType:
         """
         Determines the type of a given financial instrument symbol.
 
@@ -704,41 +687,41 @@ class Account(object):
             symbol (str): The symbol of the financial instrument (e.g., `GOOGL`, `EURUSD`).
 
         Returns:
-            Literal["STK", "ETF", "IDX", "FX", "COMD", "FUT", "CRYPTO", "BOND", "unknown"]:
-            The type of the financial instrument, one of the following:
-
-            - `STK`: For Stocks (e.g., `GOOGL`)
-            - `ETF`: For ETFs (e.g., `QQQ`)
-            - `IDX`: For Indices (e.g., `SP500`)
-            - `FX` : For Forex pairs (e.g., `EURUSD`)
-            - `COMD`: For Commodities (e.g., `CRUDOIL`, `GOLD`)
-            - `FUT` : For Futures (e.g., `USTNote_U4`)
-            - `CRYPTO`: For Cryptocurrencies (e.g., `BTC`, `ETH`)
-            - `BOND`: For Bonds (e.g., `USTN10YR`)
-
-            Returns `unknown` if the type cannot be determined.
+            SymbolType: The type of the financial instrument, one of the following:
+            - `SymbolType.ETFs`
+            - `SymbolType.BONDS`
+            - `SymbolType.FOREX`
+            - `SymbolType.FUTURES`
+            - `SymbolType.STOCKS`
+            - `SymbolType.INDICES`
+            - `SymbolType.COMMODITIES`
+            - `SymbolType.CRYPTO`
+        - `SymbolType.unknown` if the type cannot be determined.
+
         """
 
         patterns = _SYMBOLS_TYPE_
         info = self.get_symbol_info(symbol)
-        indices = self.get_symbols(symbol_type="IDX")
-        commodity = self.get_symbols(symbol_type="COMD")
+        indices = self.get_symbols(symbol_type=SymbolType.INDICES)
+        commodity = self.get_symbols(symbol_type=SymbolType.COMMODITIES)
         if info is not None:
             for symbol_type, pattern in patterns.items():
                 if (
-                    symbol_type in ["IDX", "COMD"]
+                    symbol_type in [SymbolType.COMMODITIES, SymbolType.INDICES]
                     and self.broker == PepperstoneGroupLimited()
                     and info.name.endswith("-F")
                     and info.name in indices + commodity
                 ):
-                    symbol_type = "FUT"
+                    symbol_type = SymbolType.FUTURES
                     pattern = r"\b(Forwards?)\b"
                 search = re.compile(pattern)
                 if re.search(search, info.path):
                     return symbol_type
-        return "unknown"
+        return SymbolType.unknown
 
-    def _get_symbols_by_category(self, symbol_type, category, category_map):
+    def _get_symbols_by_category(
+        self, symbol_type: SymbolType | str, category, category_map
+    ):
         if category not in category_map:
             raise ValueError(
                 f"Unsupported category: {category}. Choose from: {', '.join(category_map)}"
@@ -777,8 +760,11 @@ class Account(object):
             This mthods works primarly with Admirals Group AS products and Pepperstone Group Limited,
             For other brokers use `get_symbols()` or this method will use it by default.
         """
-        if self.broker not in [AdmiralMarktsGroup(), PepperstoneGroupLimited()]:
-            return self.get_symbols(symbol_type="FX")
+        if (
+            self.broker != AdmiralMarktsGroup()
+            or self.broker != PepperstoneGroupLimited()
+        ):
+            return self.get_symbols(symbol_type=SymbolType.FOREX)
         else:
             fx_categories = {
                 "majors": r"\b(Majors?)\b",
@@ -787,7 +773,9 @@ class Account(object):
                 "crosses": r"\b(Crosses?)\b",
                 "ndfs": r"\b(NDFs?)\b",
             }
-            return self._get_symbols_by_category("FX", category, fx_categories)
+            return self._get_symbols_by_category(
+                SymbolType.FOREX, category, fx_categories
+            )
 
     def get_stocks_from_country(
         self, country_code: str = "USA", etf=False
@@ -828,17 +816,22 @@ class Account(object):
             This mthods works primarly with Admirals Group AS products and Pepperstone Group Limited,
             For other brokers use `get_symbols()` or this method will use it by default.
         """
-
-        if self.broker not in [AdmiralMarktsGroup(), PepperstoneGroupLimited()]:
-            stocks = self.get_symbols(symbol_type="STK")
-            return stocks
+        
+        if (
+            self.broker != AdmiralMarktsGroup()
+            or self.broker != PepperstoneGroupLimited()
+        ):
+            return self.get_symbols(symbol_type=SymbolType.STOCKS)
         else:
+            stocks, etfs = [], []
             country_map = _COUNTRY_MAP_
-            stocks = self._get_symbols_by_category("STK", country_code, country_map)
-            if etf:
-                etfs = self._get_symbols_by_category("ETF", country_code, country_map)
-                return stocks + etfs
-            return stocks
+            stocks = self._get_symbols_by_category(
+                SymbolType.STOCKS, country_code, country_map
+            )
+            etfs = self._get_symbols_by_category(
+                SymbolType.ETFs, country_code, country_map
+            )
+            return stocks + etfs if etf else stocks
 
     def get_stocks_from_exchange(
         self, exchange_code: str = "XNYS", etf=True
@@ -882,15 +875,17 @@ class Account(object):
             For other brokers use `get_symbols()` or this method will use it by default.
         """
         if self.broker != AdmiralMarktsGroup():
-            stocks = self.get_symbols(symbol_type="STK")
-            return stocks
+            return self.get_symbols(symbol_type=SymbolType.STOCKS)
         else:
+            stocks, etfs = [], []
             exchange_map = AMG_EXCHANGES
-            stocks = self._get_symbols_by_category("STK", exchange_code, exchange_map)
-            if etf:
-                etfs = self._get_symbols_by_category("ETF", exchange_code, exchange_map)
-                return stocks + etfs
-            return stocks
+            stocks = self._get_symbols_by_category(
+                SymbolType.STOCKS, exchange_code, exchange_map
+            )
+            etfs = self._get_symbols_by_category(
+                    SymbolType.ETFs, exchange_code, exchange_map
+            )
+            return stocks + etfs if etf else stocks
 
     def get_future_symbols(self, category: str = "ALL") -> List[str]:
         """
@@ -913,48 +908,42 @@ class Account(object):
         """
         category = category.lower()
         if self.broker != AdmiralMarktsGroup():
-            return self.get_symbols(symbol_type="FUT")
+            return self.get_symbols(symbol_type=SymbolType.FUTURES)
         elif category in ["all", "index"]:
             categories = {
                 "all": r"\b(Futures?)\b",
                 "index": r"\b(Index)\b",
             }
-            return self._get_symbols_by_category("FUT", category, categories)
+            return self._get_symbols_by_category(
+                SymbolType.FUTURES, category, categories
+            )
         else:
-            metals = []
-            energies = []
-            agricultures = []
-            bonds = []
-            commodities = self.get_symbols(symbol_type="COMD")
-            futures = self.get_symbols(symbol_type="FUT")
+            futures_types = {}
+            for future_type in ("metals", "energies", "agricultures", "bonds"):
+                futures_types[future_type] = []
+            commodities = self.get_symbols(symbol_type=SymbolType.COMMODITIES)
+            futures = self.get_symbols(symbol_type=SymbolType.FUTURES)
             for symbol in futures:
                 info = self.get_symbol_info(symbol)
                 if info.name.startswith("_"):
                     if "XAU" in info.name:
-                        metals.append(info.name)
+                        futures_types["metals"].append(info.name)
                     if "oil" in info.name.lower():
-                        energies.append(info.name)
+                        futures_types["energies"].append(info.name)
                     name = info.name.split("_")[1]
                     if name in commodities:
                         _info = self.get_symbol_info(name)
                         if "Metals" in _info.path:
-                            metals.append(info.name)
+                            futures_types["metals"].append(info.name)
                         elif "Energies" in _info.path:
-                            energies.append(info.name)
+                            futures_types["energies"].append(info.name)
                         elif "Agricultures" in _info.path:
-                            agricultures.append(info.name)
+                            futures_types["agricultures"].append(info.name)
 
                 elif info.name.startswith("#"):
                     if "Index" not in info.path:
-                        bonds.append(info.name)
-            if category == "metals":
-                return metals
-            elif category == "energies":
-                return energies
-            elif category == "agricultures":
-                return agricultures
-            elif category == "bonds":
-                return bonds
+                        futures_types["bonds"].append(info.name)
+            return futures_types[category]
 
     def get_symbol_info(self, symbol: str) -> Union[SymbolInfo, None]:
         """Get symbol properties
@@ -978,12 +967,16 @@ class Account(object):
                 return None
             else:
                 symbol_info_dict = symbol_info._asdict()
-                time = datetime.fromtimestamp(symbol_info.time)
+                time = (
+                    datetime.fromtimestamp(symbol_info.time)
+                    if isinstance(symbol_info.time, int)
+                    else symbol_info.time
+                )
                 symbol_info_dict["time"] = time
                 return SymbolInfo(**symbol_info_dict)
         except Exception as e:
             msg = self._symbol_info_msg(symbol)
-            raise_mt5_error(message=f"{e + msg}")
+            raise_mt5_error(message=f"{str(e)} {msg}")
 
     def show_symbol_info(self, symbol: str):
         """
@@ -1024,12 +1017,16 @@ class Account(object):
                 return None
             else:
                 info_dict = tick_info._asdict()
-                time = datetime.fromtimestamp(tick_info.time)
+                time = (
+                    datetime.fromtimestamp(tick_info.time)
+                    if isinstance(tick_info.time, int)
+                    else tick_info.time
+                )
                 info_dict["time"] = time
                 return TickInfo(**info_dict)
         except Exception as e:
             msg = self._symbol_info_msg(symbol)
-            raise_mt5_error(message=f"{e + msg}")
+            raise_mt5_error(message=f"{str(e)} {msg}")
 
     def show_tick_info(self, symbol: str):
         """
@@ -1050,16 +1047,17 @@ class Account(object):
         Returns:
             The Market Depth content as a tuple from BookInfo entries featuring order type, price and volume in lots.
             Return None in case of an error.
-            
+
         Raises:
             MT5TerminalError: A specific exception based on the error code.
         """
         try:
             book = mt5.market_book_get(symbol)
-            if book is None:
-                return None
-            else:
-                return tuple([BookInfo(**entry._asdict()) for entry in book])
+            return (
+                None
+                if book is None
+                else tuple([BookInfo(**entry._asdict()) for entry in book])
+            )
         except Exception as e:
             raise_mt5_error(e)
 
@@ -1083,10 +1081,7 @@ class Account(object):
         """
         actions = {"buy": mt5.ORDER_TYPE_BUY, "sell": mt5.ORDER_TYPE_SELL}
         try:
-            margin = mt5.order_calc_margin(actions[action], symbol, lot, price)
-            if margin is None:
-                return None
-            return margin
+            return mt5.order_calc_margin(actions[action], symbol, lot, price)
         except Exception as e:
             raise_mt5_error(e)
 

bbstrader/metatrader/copier.py

@@ -302,10 +302,9 @@ class TradeCopier(object):
         if self.start_time is None or self.end_time is None:
             return True
         else:
-            now = datetime.now()
             start_time = datetime.strptime(self.start_time, "%H:%M").time()
             end_time = datetime.strptime(self.end_time, "%H:%M").time()
-            if start_time <= now.time() <= end_time:
+            if start_time <= datetime.now().time() <= end_time:
                 return True
             return False
 
@@ -327,7 +326,7 @@ class TradeCopier(object):
             dest_eqty=Account(**destination).get_account_info().margin_free,
         )
 
-        trade_instance = Trade(symbol=symbol, **destination, max_risk=100.0)
+        trade_instance = Trade(symbol=symbol, **destination, max_risk=100.0, logger=None)
         try:
             action = action_type[trade.type]
         except KeyError:
@@ -395,7 +394,7 @@ class TradeCopier(object):
 
     def remove_order(self, src_symbol, order: TradeOrder, destination: dict):
         check_mt5_connection(**destination)
-        trade = Trade(symbol=order.symbol, **destination)
+        trade = Trade(symbol=order.symbol, **destination, logger=None)
         if trade.close_order(order.ticket, id=order.magic):
             logger.info(
                 f"Close Order #{order.ticket} on @{destination.get('login')}::{order.symbol}, "
@@ -438,7 +437,7 @@ class TradeCopier(object):
 
     def remove_position(self, src_symbol, position: TradePosition, destination: dict):
         check_mt5_connection(**destination)
-        trade = Trade(symbol=position.symbol, **destination)
+        trade = Trade(symbol=position.symbol, **destination, logger=None)
         if trade.close_position(position.ticket, id=position.magic):
             logger.info(
                 f"Close Position #{position.ticket} on @{destination.get('login')}::{position.symbol}, "
@@ -626,7 +625,7 @@ class TradeCopier(object):
                     time.sleep(0.1)
             except KeyboardInterrupt:
                 logger.info("Stopping the Trade Copier ...")
-                break
+                exit(0)
             except Exception as e:
                 self.log_error(e)
             time.sleep(self.sleeptime)

bbstrader/metatrader/rates.py

@@ -7,7 +7,7 @@ from pandas.tseries.holiday import USFederalHolidayCalendar
 from pandas.tseries.offsets import CustomBusinessDay
 
 from bbstrader.metatrader.account import AMG_EXCHANGES, Account, check_mt5_connection
-from bbstrader.metatrader.utils import TIMEFRAMES, TimeFrame, raise_mt5_error
+from bbstrader.metatrader.utils import TIMEFRAMES, TimeFrame, raise_mt5_error, SymbolType
 
 try:
     import MetaTrader5 as Mt5
@@ -46,13 +46,13 @@ COMD_CALENDARS = {
 }
 
 CALENDARS = {
-    "FX": "us_futures",
-    "STK": AMG_EXCHANGES,
-    "ETF": AMG_EXCHANGES,
-    "IDX": IDX_CALENDARS,
-    "COMD": COMD_CALENDARS,
-    "CRYPTO": "24/7",
-    "FUT": None,
+    SymbolType.FOREX: "us_futures",
+    SymbolType.STOCKS: AMG_EXCHANGES,
+    SymbolType.ETFs: AMG_EXCHANGES,
+    SymbolType.INDICES: IDX_CALENDARS,
+    SymbolType.COMMODITIES: COMD_CALENDARS,
+    SymbolType.CRYPTO: "24/7",
+    SymbolType.FUTURES: None,
 }
 
 SESSION_TIMEFRAMES = [
@@ -206,6 +206,7 @@ class Rates(object):
     ) -> Union[pd.DataFrame, None]:
         """Fetches data from MT5 and returns a DataFrame or None."""
         try:
+            rates = None
             if isinstance(start, int) and isinstance(count, int):
                 rates = Mt5.copy_rates_from_pos(
                     self.symbol, self.time_frame, start, count
@@ -248,7 +249,7 @@ class Rates(object):
         currencies = self.__account.get_currency_rates(self.symbol)
         s_info = self.__account.get_symbol_info(self.symbol)
         if symbol_type in CALENDARS:
-            if symbol_type == "STK" or symbol_type == "ETF":
+            if symbol_type == SymbolType.STOCKS or symbol_type == SymbolType.ETFs:
                 for exchange in CALENDARS[symbol_type]:
                     if exchange in get_calendar_names():
                         symbols = self.__account.get_stocks_from_exchange(
@@ -257,20 +258,20 @@ class Rates(object):
                         if self.symbol in symbols:
                             calendar = get_calendar(exchange, side="right")
                             break
-            elif symbol_type == "IDX":
+            elif symbol_type == SymbolType.INDICES:
                 calendar = get_calendar(
                     CALENDARS[symbol_type][currencies["mc"]], side="right"
                 )
-            elif symbol_type == "COMD":
+            elif symbol_type == SymbolType.COMMODITIES:
                 for commodity in CALENDARS[symbol_type]:
                     if commodity in s_info.path:
                         calendar = get_calendar(
                             CALENDARS[symbol_type][commodity], side="right"
                         )
-            elif symbol_type == "FUT":
+            elif symbol_type == SymbolType.FUTURES:
                 if "Index" in s_info.path:
                     calendar = get_calendar(
-                        CALENDARS["IDX"][currencies["mc"]], side="right"
+                        CALENDARS[SymbolType.INDICES][currencies["mc"]], side="right"
                     )
                 else:
                     for commodity, cal in COMD_CALENDARS.items():

bbstrader/metatrader/risk.py

@@ -6,7 +6,7 @@ from scipy.stats import norm
 
 from bbstrader.metatrader.account import Account
 from bbstrader.metatrader.rates import Rates
-from bbstrader.metatrader.utils import TIMEFRAMES, TimeFrame
+from bbstrader.metatrader.utils import TIMEFRAMES, TimeFrame, SymbolType
 
 try:
     import MetaTrader5 as Mt5
@@ -275,10 +275,12 @@ class RiskManagement(Account):
             swap = df["swap"].sum()
             total_profit = commisions + fees + swap + profit
             initial_balance = balance - total_profit
-            if balance != 0:
+            if equity != 0:
                 risk_alowed = (((equity - initial_balance) / equity) * 100) * -1
                 return round(risk_alowed, 2)
-        return 0.0
+            else: # Handle equity is zero
+                return 0.0
+        return 0.0 # This is for the case where df is None
 
     def get_lot(self) -> float:
         """ "Get the approprite lot size for a trade"""
@@ -498,10 +500,10 @@ class RiskManagement(Account):
         av_price = (s_info.bid + s_info.ask) / 2
         trade_risk = self.get_trade_risk()
         symbol_type = self.get_symbol_type(self.symbol)
-        FX = symbol_type == "FX"
-        COMD = symbol_type == "COMD"
-        FUT = symbol_type == "FUT"
-        CRYPTO = symbol_type == "CRYPTO"
+        FX = symbol_type == SymbolType.FOREX
+        COMD = symbol_type == SymbolType.COMMODITIES
+        FUT = symbol_type == SymbolType.FUTURES
+        CRYPTO = symbol_type == SymbolType.CRYPTO
         if COMD:
             supported = _COMMD_SUPPORTED_
             if "." in self.symbol:
@@ -652,14 +654,14 @@ class RiskManagement(Account):
         lot = self._check_lot(_lot)
 
         volume = round(lot * size * av_price)
-        if self.get_symbol_type(self.symbol) == "FX":
+        if self.get_symbol_type(self.symbol) == SymbolType.FOREX:
             volume = round((trade_loss * size) / loss)
             __lot = round((volume / size), 2)
             lot = self._check_lot(__lot)
 
         if (
-            self.get_symbol_type(self.symbol) == "COMD"
-            or self.get_symbol_type(self.symbol) == "CRYPTO"
+            self.get_symbol_type(self.symbol) == SymbolType.COMMODITIES
+            or self.get_symbol_type(self.symbol) == SymbolType.CRYPTO
             and size > 1
         ):
             lot = currency_risk / (sl * loss * size)
@@ -705,7 +707,7 @@ class RiskManagement(Account):
         if account:
             return AL
 
-        if self.get_symbol_type(self.symbol) == "FX":
+        if self.get_symbol_type(self.symbol) == SymbolType.FOREX:
             return AL
         else:
             s_info = self.symbol_info