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

bbstrader/metatrader/rates.py

@@ -3,13 +3,66 @@ import MetaTrader5 as Mt5
 from datetime import datetime
 from typing import Union, Optional
 from bbstrader.metatrader.utils import (
-    raise_mt5_error, TimeFrame, TIMEFRAMES)
-from bbstrader.metatrader.account import INIT_MSG
+    raise_mt5_error, 
+    TimeFrame, 
+    TIMEFRAMES
+)
+from bbstrader.metatrader.account import Account
+from bbstrader.metatrader.account import AMG_EXCHANGES
+from bbstrader.metatrader.account import check_mt5_connection
 from pandas.tseries.offsets import CustomBusinessDay
 from pandas.tseries.holiday import USFederalHolidayCalendar
+from exchange_calendars import(
+    get_calendar,
+    get_calendar_names
+)
+
+__all__ = [
+    'Rates', 
+    'download_historical_data', 
+    'get_data_from_pos'
+]
 
 MAX_BARS = 10_000_000
 
+IDX_CALENDARS = {
+    "CAD": "XTSE",
+    "AUD": "XASX",
+    "GBP": "XLON",
+    "HKD": "XSHG",
+    "ZAR": "XJSE",
+    "CHF": "XSWX",
+    "NOK": "XOSL",
+    "EUR": "XETR",
+    "SGD": "XSES",
+    "USD": "us_futures",
+    "JPY": "us_futures",
+}
+
+COMD_CALENDARS = {
+    "Energies"      : "us_futures",
+    "Metals"        : "us_futures",
+    "Agricultures"  : "CBOT",
+    "Bonds": {"USD" : "CBOT", "EUR": "EUREX"},
+}
+
+CALENDARS = {
+    "FX"    : "us_futures",
+    "STK"   : AMG_EXCHANGES,
+    "ETF"   : AMG_EXCHANGES,
+    "IDX"   : IDX_CALENDARS,
+    "COMD"  : COMD_CALENDARS,
+    "CRYPTO": "24/7",
+    "FUT"   : None,
+}
+
+SESSION_TIMEFRAMES = [
+    Mt5.TIMEFRAME_D1,
+    Mt5.TIMEFRAME_W1,
+    Mt5.TIMEFRAME_H12,
+    Mt5.TIMEFRAME_MN1
+]
+
 
 class Rates(object):
     """
@@ -26,8 +79,8 @@ class Rates(object):
         or just set it to Unlimited.
         In your MT5 terminal, go to `Tools` -> `Options` -> `Charts` -> `Max bars in chart`.
         
-        2. The `get_open, get_high, get_low, get_close, get_adj_close, get_returns,
-        get_volume` properties returns data in  Broker's timezone.
+        2. The `open, high, low, close, adjclose, returns,
+        volume` properties returns data in  Broker's timezone by default.
 
     Example:
         >>> rates = Rates("EURUSD", "1h")
@@ -70,13 +123,11 @@ class Rates(object):
         self.start_pos = self._get_start_pos(start_pos, time_frame)
         self.count = count
         self._mt5_initialized()
+        self.__account = Account()
         self.__data = self.get_rates_from_pos()
 
-
     def _mt5_initialized(self):
-        """Ensures the MetaTrader 5 Terminal is initialized."""
-        if not Mt5.initialize():
-            raise_mt5_error(message=INIT_MSG)
+        check_mt5_connection()
     
     def _get_start_pos(self, index, time_frame):
         if isinstance(index, int):
@@ -127,8 +178,8 @@ class Rates(object):
         return TIMEFRAMES[time_frame]
 
     def _fetch_data(
-        self, start: Union[int, datetime],
-        count: Union[int, datetime]
+        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:
@@ -136,7 +187,10 @@ class Rates(object):
                 rates = Mt5.copy_rates_from_pos(
                     self.symbol, self.time_frame, start, count
                 )
-            elif isinstance(start, datetime) and isinstance(count, datetime):
+            elif (
+                isinstance(start, (datetime, pd.Timestamp)) and 
+                isinstance(count, (datetime, pd.Timestamp))
+                ):
                 rates = Mt5.copy_rates_range(
                     self.symbol, self.time_frame, start, count
                 )
@@ -144,28 +198,103 @@ class Rates(object):
                 return None
 
             df = pd.DataFrame(rates)
-            return self._format_dataframe(df)
+            return self._format_dataframe(df, lower_colnames=lower_colnames, utc=utc)
         except Exception as e:
             raise_mt5_error(e)
 
-    def _format_dataframe(self, df: pd.DataFrame) -> pd.DataFrame:
+    def _format_dataframe(self, df: pd.DataFrame, 
+                          lower_colnames=False, utc=False) -> pd.DataFrame:
         """Formats the raw MT5 data into a standardized DataFrame."""
         df = df.copy()
         df = df[['time', 'open', 'high', 'low', 'close', 'tick_volume']]
         df.columns = ['Date', 'Open', 'High', 'Low', 'Close', 'Volume']
         df['Adj Close'] = df['Close']
         df = df[['Date', 'Open', 'High', 'Low', 'Close', 'Adj Close', 'Volume']]
-        df['Date'] = pd.to_datetime(df['Date'], unit='s')
+        #df = df.columns.rename(str.lower).str.replace(' ', '_')
+        df['Date'] = pd.to_datetime(df['Date'], unit='s', utc=utc)
         df.set_index('Date', inplace=True)
+        if lower_colnames:
+            df.columns = df.columns.str.lower().str.replace(' ', '_')
+            df.index.name = df.index.name.lower().replace(' ', '_')
         return df
 
-    def get_rates_from_pos(self) -> Union[pd.DataFrame, None]:
+    def _filter_data(self, df: pd.DataFrame, date_from=None, date_to=None, fill_na=False) -> pd.DataFrame:
+        df = df.copy()
+        symbol_type = self.__account.get_symbol_type(self.symbol)
+        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':
+                for exchange in CALENDARS[symbol_type]:
+                    if exchange in get_calendar_names():
+                        symbols = self.__account.get_stocks_from_exchange(
+                            exchange_code=exchange)
+                        if self.symbol in symbols:
+                            calendar = get_calendar(exchange, side='right')
+                            break
+            elif symbol_type == 'IDX':
+                calendar = get_calendar(CALENDARS[symbol_type][currencies['mc']], side='right')
+            elif symbol_type == 'COMD':
+                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':
+                if 'Index' in s_info.path:
+                    calendar = get_calendar(CALENDARS['IDX'][currencies['mc']], side='right')
+                else:
+                    for commodity, cal in COMD_CALENDARS.items():
+                        if self.symbol in self.__account.get_future_symbols(category=commodity):
+                            if commodity == 'Bonds':
+                                calendar = get_calendar(cal[currencies['mc']], side='right')
+                            else:
+                                calendar = get_calendar(cal, side='right')
+            else:
+                calendar = get_calendar(CALENDARS[symbol_type], side='right')
+            date_from = date_from or df.index[0]
+            date_to = date_to or df.index[-1]
+            if self.time_frame in SESSION_TIMEFRAMES:
+                valid_sessions = calendar.sessions_in_range(date_from, date_to)
+            else:
+                valid_sessions = calendar.minutes_in_range(date_from, date_to)
+            if self.time_frame in [Mt5.TIMEFRAME_M1, Mt5.TIMEFRAME_D1]:
+                # save the index name of the dataframe
+                index_name = df.index.name
+                if fill_na:
+                    if isinstance(fill_na, bool):
+                        method =  'nearest'
+                    if isinstance(fill_na, str):
+                        method = fill_na
+                    df = df.reindex(valid_sessions, method=method)
+                else:
+                    df.reindex(valid_sessions, method=None)
+                df.index = df.index.rename(index_name)
+            else:
+                df = df[df.index.isin(valid_sessions)]
+        return df
+    
+    def _check_filter(self, filter, utc):
+        if filter and self.time_frame not in SESSION_TIMEFRAMES and not utc:
+            utc = True
+        elif filter and self.time_frame in SESSION_TIMEFRAMES and utc:
+            utc = False
+        return utc
+    
+    def get_rates_from_pos(self, filter=False, fill_na=False, 
+                           lower_colnames=False, utc=False
+                           ) -> Union[pd.DataFrame, None]:
         """
         Retrieves historical data starting from a specific position.
 
         Uses the `start_pos` and `count` attributes specified during
         initialization to fetch data.
 
+        Args:
+            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.
@@ -182,31 +311,37 @@ class Rates(object):
                 "Both 'start_pos' and 'count' must be provided "
                 "when calling 'get_rates_from_pos'."
             )
-        df = self._fetch_data(self.start_pos, self.count)
+        utc = self._check_filter(filter, utc)
+        df = self._fetch_data(self.start_pos, self.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 get_open(self):
+    def open(self):
         return self.__data['Open']
         
     @property
-    def get_high(self):
+    def high(self):
         return self.__data['High']
     
     @property
-    def get_low(self):
+    def low(self):
         return self.__data['Low']
     
     @property
-    def get_close(self):
+    def close(self):
         return self.__data['Close']
 
     @property
-    def get_adj_close(self):
+    def adjclose(self):
         return self.__data['Adj Close']
     
     @property
-    def get_returns(self):
+    def returns(self):
         """
         Fractional change between the current and a prior element.
 
@@ -224,23 +359,52 @@ class Rates(object):
         return data['Returns']
     
     @property
-    def get_volume(self):
+    def volume(self):
         return self.__data['Volume']
 
     def get_historical_data(
         self,
-        date_from: datetime,
-        date_to: datetime = datetime.now(),
+        date_from: datetime | pd.Timestamp,
+        date_to: datetime | pd.Timestamp = pd.Timestamp.now(),
+        utc: bool = False,
+        filter: Optional[bool] = False,
+        fill_na: Optional[bool | str] = False,
+        lower_colnames: Optional[bool] = True,
         save_csv: Optional[bool] = False,
     ) -> Union[pd.DataFrame, None]:
         """
         Retrieves historical data within a specified date range.
 
         Args:
-            date_from (datetime): Starting date for data retrieval.
-            date_to (datetime, optional): Ending date for data retrieval.
+            date_from : Starting date for data retrieval.
+            
+            date_to : Ending date for data retrieval.
                 Defaults to the current time.
-            save_csv (str, optional): File path to save the data as a CSV.
+            
+            utc : If True, the data will be in UTC timezone.
+                Defaults to False.
+            
+            filter : If True, the data will be filtered based
+                on the trading sessions for the symbol.
+                This is use when we want to use the data for backtesting using Zipline.
+            
+            fill_na : If True, the data will be filled with the nearest value.
+                This is use only when `filter` is True and time frame is "1m" or "D1",
+                this is because we use ``calendar.minutes_in_range`` or ``calendar.sessions_in_range``
+                where calendar is the ``ExchangeCalendar`` from `exchange_calendars` package.
+                So, for "1m" or "D1" time frame, the data will be filled with the nearest value
+                because the data from MT5 will have approximately the same number of rows as the
+                number of trading days or minute in the exchange calendar, so we can fill the missing
+                data with the nearest value.
+                
+                But for other time frames, the data will be reindexed with the exchange calendar
+                because the data from MT5 will have more rows than the number of trading days or minute
+                in the exchange calendar. So we only take the data that is in the range of the exchange
+                calendar sessions or minutes.
+            
+            lower_colnames : If True, the column names will be converted to lowercase.
+            
+            save_csv : File path to save the data as a CSV.
                 If None, the data won't be saved.
 
         Returns:
@@ -251,9 +415,48 @@ class Rates(object):
             ValueError: If the starting date is greater than the ending date.
         
         Notes:
-            The Datetime for this method is in Local timezone.
+            The `filter` for this method can be use only for Admira Markets Group (AMG) symbols.
+            The Datetime for this method is in Local timezone by default.
+            All STK symbols are filtered based on the the exchange calendar.
+            All FX symbols are filtered based on the ``us_futures`` calendar.
+            All IDX symbols are filtered based on the exchange calendar of margin currency.
+            All COMD symbols are filtered based on the exchange calendar of the commodity.
         """
-        df = self._fetch_data(date_from, date_to)
-        if save_csv and df is not None:
+        utc = self._check_filter(filter, utc)
+        df = self._fetch_data(date_from, date_to,
+                              lower_colnames=lower_colnames, utc=utc)
+        if df is None:
+            return None
+        if filter:
+            df = self._filter_data(df, date_from=date_from, date_to=date_to, fill_na=fill_na)
+        if save_csv:
             df.to_csv(f"{self.symbol}.csv")
         return df
+
+def download_historical_data(symbol, time_frame, date_from, 
+                             date_to=pd.Timestamp.now(),lower_colnames=True, 
+                             utc=False, filter=False, fill_na=False, save_csv=False):
+    """Download historical data from MetaTrader 5 terminal.
+    See `Rates.get_historical_data` for more details.
+    """
+    rates = Rates(symbol, time_frame)
+    data = rates.get_historical_data(
+        date_from=date_from,
+        date_to=date_to,
+        save_csv=save_csv,
+        utc=utc,
+        filter=filter,
+        lower_colnames=lower_colnames
+    )
+    return data
+
+def get_data_from_pos(symbol, time_frame, start_pos=0, fill_na=False, 
+                      count=MAX_BARS, lower_colnames=False, utc=False, filter=False,
+                        session_duration=23.0):
+    """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)
+    data = rates.get_rates_from_pos(filter=filter, fill_na=fill_na,
+                                    lower_colnames=lower_colnames, utc=utc)
+    return data

bbstrader/metatrader/risk.py

@@ -7,8 +7,18 @@ import MetaTrader5 as Mt5
 from bbstrader.metatrader.account import Account
 from bbstrader.metatrader.rates import Rates
 from bbstrader.metatrader.utils import (
-    TIMEFRAMES, raise_mt5_error, TimeFrame)
-from typing import List, Dict, Optional, Literal, Union, Any
+    TIMEFRAMES, 
+    raise_mt5_error, 
+    TimeFrame
+)
+from typing import (
+    List, 
+    Dict, 
+    Optional, 
+    Literal, 
+    Union, 
+    Any
+)
 
 
 _COMMD_SUPPORTED_ = [
@@ -16,7 +26,6 @@ _COMMD_SUPPORTED_ = [
     'XAGEUR', 'XAGUSD', 'XAUAUD', 'XAUEUR', 'XAUUSD', 'XAUGBP',  'USOIL'
 ]
 
-
 _ADMIRAL_MARKETS_FUTURES_ = [
     '#USTNote_', '#Bund_', '#USDX_', '_AUS200_', '_Canada60_', '_SouthAfrica40_',
     '_STXE600_', '_EURO50_', '_GER40_', '_GermanyTech30_', '_MidCapGER50_',
@@ -25,6 +34,7 @@ _ADMIRAL_MARKETS_FUTURES_ = [
     '_XAU_', '_HK50_', '_HSCEI50_'
 ]
 
+__all__ = ['RiskManagement']
 
 class RiskManagement(Account):
     """
@@ -135,7 +145,7 @@ class RiskManagement(Account):
         self.pchange = pchange_sl
         self.var_level = var_level
         self.var_tf = var_time_frame
-        self.daily_dd = daily_risk
+        self.daily_dd = round(daily_risk, 5)
         self.max_risk = max_risk
         self.rr = rr
         self.sl = sl
@@ -193,7 +203,7 @@ class RiskManagement(Account):
         volume_step = s_info.volume_step
         lot = self.currency_risk()['lot']
         steps = self._volume_step(volume_step)
-        if steps >= 2:
+        if float(steps) >= float(1):
             return round(lot, steps)
         else:
             return round(lot)
@@ -203,13 +213,13 @@ class RiskManagement(Account):
 
         value_str = str(value)
 
-        if '.' in value_str:
+        if '.' in value_str and value_str != '1.0':
             decimal_index = value_str.index('.')
             num_digits = len(value_str) - decimal_index - 1
-
             return num_digits
-        elif value_str == '1':
-            return 1
+        
+        elif value_str == '1.0':
+            return 0
         else:
             return 0
 
@@ -254,7 +264,7 @@ class RiskManagement(Account):
         interval = round((minutes / tf_int)  * 252)
 
         rate = Rates(self.symbol, self._tf, 0, interval)
-        returns = rate.get_returns*100
+        returns = rate.returns*100
         std = returns.std()
         point = self.get_symbol_info(self.symbol).point
         av_price = (self.symbol_info.bid + self.symbol_info.ask)/2
@@ -308,7 +318,7 @@ class RiskManagement(Account):
         interval = round((minutes / tf_int)  * 252)
 
         rate = Rates(self.symbol, tf, 0, interval)
-        returns = rate.get_returns*100
+        returns = rate.returns*100
         p = self.get_account_info().margin_free
         mu = returns.mean()
         sigma = returns.std()
@@ -341,7 +351,7 @@ class RiskManagement(Account):
         """
         P = self.get_account_info().margin_free
         trade_risk = self.get_trade_risk()
-        loss_allowed = P * trade_risk
+        loss_allowed = P * trade_risk / 100
         var = self.calculate_var(c=self.var_level, tf=self.var_tf)
         return min(var, loss_allowed)
 
@@ -405,10 +415,11 @@ class RiskManagement(Account):
 
         av_price = (s_info.bid + s_info.ask)/2
         trade_risk = self.get_trade_risk()
-        FX = self.get_symbol_type(self.symbol) == 'FX'
-        COMD = self.get_symbol_type(self.symbol) == 'COMD'
-        FUT = self.get_symbol_type(self.symbol) == 'FUT'
-        CRYPTO = self.get_symbol_type(self.symbol) == 'CRYPTO'
+        symbol_type = self.get_symbol_type(self.symbol)
+        FX    = symbol_type == 'FX'
+        COMD  = symbol_type == 'COMD'
+        FUT   = symbol_type == 'FUT'
+        CRYPTO = symbol_type == 'CRYPTO'
         if COMD:
             supported = _COMMD_SUPPORTED_
             if self.symbol.split('.')[0] not in supported:
@@ -503,14 +514,14 @@ class RiskManagement(Account):
                     trade_loss = (lot * contract_size) * tick_value_loss
                     trade_profit = (lot * contract_size) * tick_value_profit
 
-            if self.get_symbol_type(self.symbol) == 'IDX':
-                rates = self.get_currency_rates(self.symbol)
-                if rates['mc'] == rates['pc'] == 'JPY':
-                    lot = lot * contract_size
-                    lot = self._check_lot(lot)
-                    volume = round(lot * av_price * contract_size)
-            if contract_size == 1:
-                volume = round(lot * av_price)
+            # if self.get_symbol_type(self.symbol) == 'IDX':
+            #     rates = self.get_currency_rates(self.symbol)
+            #     if rates['mc'] == rates['pc'] == 'JPY':
+            #         lot = lot * contract_size
+            #         lot = self._check_lot(lot)
+            #         volume = round(lot * av_price * contract_size)
+            # if contract_size == 1:
+            #     volume = round(lot * av_price)
 
             return {
                 'currency_risk': currency_risk,