bbstrader 0.2.91__py3-none-any.whl → 0.2.92__py3-none-any.whl

bbstrader/__main__.py

@@ -0,0 +1,50 @@
+import argparse
+import sys
+
+import pyfiglet
+from colorama import Fore
+
+from bbstrader.btengine.scripts import backtest
+from bbstrader.metatrader.scripts import copy_trades
+from bbstrader.trading.script import execute_strategy
+
+DESCRIPTION = "BBSTRADER"
+USAGE_TEXT = """
+    Usage:
+        python -m bbstrader --run <module> [options]
+
+    Modules:
+        copier: Copy trades from one MetaTrader account to another or multiple accounts
+        backtest: Backtest a strategy, see bbstrader.btengine.backtest.run_backtest
+        execution: Execute a strategy, see bbstrader.trading.execution.MT5ExecutionEngine
+    
+    run <module> --help for more information on the module
+"""
+
+FONT = pyfiglet.figlet_format("BBSTRADER", font="big")
+
+
+def main():
+    print(Fore.BLUE + FONT)
+    parser = argparse.ArgumentParser(
+        prog="BBSTRADER",
+        usage=USAGE_TEXT,
+        description=DESCRIPTION,
+        formatter_class=argparse.RawTextHelpFormatter,
+        add_help=False,
+    )
+    parser.add_argument("--run", type=str, nargs="?", default=None, help="Run a module")
+    args, unknown = parser.parse_known_args()
+    if ("-h" in sys.argv or "--help" in sys.argv) and args.run is None:
+        print(USAGE_TEXT)
+        sys.exit(0)
+    if args.run == "copier":
+        copy_trades(unknown)
+    elif args.run == "backtest":
+        backtest(unknown)
+    elif args.run == "execution":
+        execute_strategy(unknown)
+
+
+if __name__ == "__main__":
+    main()

bbstrader/btengine/data.py

@@ -496,6 +496,7 @@ class YFDataHandler(BaseCSVDataHandler):
                     start=self.start_date,
                     end=self.end_date,
                     multi_level_index=False,
+                    auto_adjust=True,
                     progress=False,
                 )
                 if "Adj Close" not in data.columns:

bbstrader/btengine/execution.py

@@ -1,13 +1,24 @@
 from abc import ABCMeta, abstractmethod
 from queue import Queue
 
+from loguru import logger
+
 from bbstrader.btengine.data import DataHandler
 from bbstrader.btengine.event import FillEvent, OrderEvent
+from bbstrader.config import BBSTRADER_DIR
 from bbstrader.metatrader.account import Account
 
 __all__ = ["ExecutionHandler", "SimExecutionHandler", "MT5ExecutionHandler"]
 
 
+logger.add(
+    f"{BBSTRADER_DIR}/logs/execution.log",
+    enqueue=True,
+    level="INFO",
+    format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {name} | {message}",
+)
+
+
 class ExecutionHandler(metaclass=ABCMeta):
     """
     The ExecutionHandler abstract class handles the interaction
@@ -59,7 +70,7 @@ class SimExecutionHandler(ExecutionHandler):
         """
         self.events = events
         self.bardata = data
-        self.logger = kwargs.get("logger")
+        self.logger = kwargs.get("logger") or logger
 
     def execute_order(self, event: OrderEvent):
         """
@@ -123,7 +134,7 @@ class MT5ExecutionHandler(ExecutionHandler):
         """
         self.events = events
         self.bardata = data
-        self.logger = kwargs.get("logger")
+        self.logger = kwargs.get("logger") or logger
         self.__account = Account(**kwargs)
 
     def _calculate_lot(self, symbol, quantity, price):

bbstrader/btengine/performance.py

@@ -1,3 +1,4 @@
+from typing import Dict, List
 import warnings
 
 import matplotlib.pyplot as plt
@@ -19,8 +20,56 @@ __all__ = [
     "plot_returns_and_dd",
     "plot_monthly_yearly_returns",
     "show_qs_stats",
+    "get_asset_performances",
+    "get_perfbased_weights",
 ]
 
+def get_asset_performances(
+    portfolio: pd.DataFrame, assets: List[str], plot=True, strategy=""
+) -> pd.Series:
+    """
+    Calculate the performance of the assets in the portfolio.
+
+    Args:
+        portfolio (pd.DataFrame): The portfolio DataFrame.
+        assets (List[str]): The list of assets to calculate the performance for.
+        plot (bool): Whether to plot the performance of the assets.
+        strategy (str): The name of the strategy.
+
+    Returns:
+        pd.Series: The performance of the assets.
+    """
+    asset_prices = portfolio[assets]
+    asset_prices = asset_prices.abs()
+    asset_prices.replace(0, np.nan, inplace=True)
+    asset_prices.ffill(inplace=True)
+    asset_returns = asset_prices.pct_change()
+    asset_returns.replace([np.inf, -np.inf], np.nan, inplace=True)
+    asset_returns.fillna(0, inplace=True)
+    asset_cum_returns = (1.0 + asset_returns).cumprod()
+    if plot:
+        asset_cum_returns.plot(figsize=(12, 6), title=f"{strategy} Strategy Assets Performance")
+        plt.show()
+    return asset_cum_returns.iloc[-1] - 1
+
+
+def get_perfbased_weights(performances) -> Dict[str, float]:
+    """
+    Calculate the weights of the assets based on their performances.
+
+    Args:
+        performances (pd.Series): The performances of the assets.
+
+    Returns:
+        Dict[str, float]: The weights of the assets.
+    """
+    weights = (
+        performances.to_frame()
+        .assign(weight=performances.values / performances.sum())
+        .weight.to_dict()
+    )
+    return weights
+
 
 def create_sharpe_ratio(returns, periods=252) -> float:
     """
@@ -173,7 +222,7 @@ def plot_returns_and_dd(df: pd.DataFrame, benchmark: str, title):
     # To avoid errors, we use the try-except block
     # in case the benchmark is not available
     try:
-        bm = yf.download(benchmark, start=first_date, end=last_date)
+        bm = yf.download(benchmark, start=first_date, end=last_date, auto_adjust=True)
         bm["log_return"] = np.log(bm["Close"] / bm["Close"].shift(1))
         # Use exponential to get cumulative returns
         bm_returns = np.exp(np.cumsum(bm["log_return"].fillna(0)))

bbstrader/btengine/scripts.py

@@ -0,0 +1,157 @@
+import argparse
+import json
+import os
+import sys
+from datetime import datetime
+
+from bbstrader.btengine.backtest import run_backtest
+from bbstrader.btengine.data import (
+    CSVDataHandler,
+    DataHandler,
+    EODHDataHandler,
+    FMPDataHandler,
+    MT5DataHandler,
+    YFDataHandler,
+)
+from bbstrader.btengine.execution import (
+    ExecutionHandler,
+    MT5ExecutionHandler,
+    SimExecutionHandler,
+)
+from bbstrader.core.utils import load_class, load_module
+
+BACKTEST_PATH = os.path.expanduser("~/.bbstrader/backtest/backtest.py")
+CONFIG_PATH = os.path.expanduser("~/.bbstrader/backtest/backtest.json")
+
+DATA_HANDLER_MAP = {
+    "csv": CSVDataHandler,
+    "mt5": MT5DataHandler,
+    "yf": YFDataHandler,
+    "eodh": EODHDataHandler,
+    "fmp": FMPDataHandler,
+}
+
+EXECUTION_HANDLER_MAP = {
+    "sim": SimExecutionHandler,
+    "mt5": MT5ExecutionHandler,
+}
+
+
+def load_exc_handler(module, handler_name):
+    return load_class(module, handler_name, ExecutionHandler)
+
+
+def load_data_handler(module, handler_name):
+    return load_class(module, handler_name, DataHandler)
+
+
+def load_strategy(module, strategy_name):
+    from bbstrader.btengine.strategy import MT5Strategy, Strategy
+
+    return load_class(module, strategy_name, (Strategy, MT5Strategy))
+
+
+def load_config(config_path, strategy_name):
+    if not os.path.exists(config_path):
+        raise FileNotFoundError(
+            f"Configuration file {config_path} not found. Please create it."
+        )
+
+    with open(config_path, "r") as f:
+        config = json.load(f)
+    try:
+        config = config[strategy_name]
+    except KeyError:
+        raise ValueError(
+            f"Strategy {strategy_name} not found in the configuration file."
+        )
+
+    required_fields = ["symbol_list", "start_date", "data_handler", "execution_handler"]
+    for field in required_fields:
+        if not config.get(field):
+            raise ValueError(f"{field} is required in the configuration file.")
+
+    config["start_date"] = datetime.strptime(config["start_date"], "%Y-%m-%d")
+
+    if config.get("execution_handler") not in EXECUTION_HANDLER_MAP:
+        try:
+            backtest_module = load_module(BACKTEST_PATH)
+            exc_handler_class = load_exc_handler(
+                backtest_module, config["execution_handler"]
+            )
+        except Exception as e:
+            raise ValueError(f"Invalid execution handler: {e}")
+    else:
+        exc_handler_class = EXECUTION_HANDLER_MAP[config["execution_handler"]]
+
+    if config.get("data_handler") not in DATA_HANDLER_MAP:
+        try:
+            backtest_module = load_module(BACKTEST_PATH)
+            data_handler_class = load_data_handler(
+                backtest_module, config["data_handler"]
+            )
+        except Exception as e:
+            raise ValueError(f"Invalid data handler: {e}")
+    else:
+        data_handler_class = DATA_HANDLER_MAP[config["data_handler"]]
+
+    config["execution_handler"] = exc_handler_class
+    config["data_handler"] = data_handler_class
+
+    return config
+
+
+def backtest(unknown):
+    HELP_MSG = """
+    Usage:
+        python -m bbstrader --run backtest [options]
+
+    Options:
+        -s, --strategy: Strategy class name to run
+        -c, --config: Configuration file path (default: ~/.bbstrader/backtest/backtest.json)
+        -p, --path: Path to the backtest file (default: ~/.bbstrader/backtest/backtest.py)
+    
+    Note:
+        The configuration file must contain all the required parameters 
+        for the data handler and execution handler and strategy.
+        See bbstrader.btengine.BacktestEngine for more details on the parameters.
+    """
+    if "-h" in unknown or "--help" in unknown:
+        print(HELP_MSG)
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(description="Backtesting Engine CLI")
+    parser.add_argument(
+        "-s", "--strategy", type=str, required=True, help="Strategy class name to run"
+    )
+    parser.add_argument(
+        "-c", "--config", type=str, default=CONFIG_PATH, help="Configuration file path"
+    )
+    parser.add_argument(
+        "-p",
+        "--path",
+        type=str,
+        default=BACKTEST_PATH,
+        help="Path to the backtest file",
+    )
+    args = parser.parse_args(unknown)
+    config = load_config(args.config, args.strategy)
+    strategy_module = load_module(args.path)
+    strategy_class = load_strategy(strategy_module, args.strategy)
+
+    symbol_list = config.pop("symbol_list")
+    start_date = config.pop("start_date")
+    data_handler = config.pop("data_handler")
+    execution_handler = config.pop("execution_handler")
+
+    try:
+        run_backtest(
+            symbol_list,
+            start_date,
+            data_handler,
+            strategy_class,
+            exc_handler=execution_handler,
+            **config,
+        )
+    except Exception as e:
+        print(f"Error: {e}")

bbstrader/btengine/strategy.py

@@ -7,9 +7,12 @@ from typing import Dict, List, Literal, Union
 import numpy as np
 import pandas as pd
 import pytz
+from loguru import logger
 
 from bbstrader.btengine.data import DataHandler
 from bbstrader.btengine.event import FillEvent, SignalEvent
+from bbstrader.config import BBSTRADER_DIR
+from bbstrader.core.utils import TradeSignal
 from bbstrader.metatrader.account import (
     Account,
     AdmiralMarktsGroup,
@@ -17,10 +20,16 @@ from bbstrader.metatrader.account import (
 )
 from bbstrader.metatrader.rates import Rates
 from bbstrader.models.optimization import optimized_weights
-from bbstrader.core.utils import TradeSignal
 
 __all__ = ["Strategy", "MT5Strategy"]
 
+logger.add(
+    f"{BBSTRADER_DIR}/logs/strategy.log",
+    enqueue=True,
+    level="INFO",
+    format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {name} | {message}",
+)
+
 
 class Strategy(metaclass=ABCMeta):
     """
@@ -91,10 +100,11 @@ class MT5Strategy(Strategy):
         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.logger = kwargs.get("logger") or logger
         if self.mode == "backtest":
             self._initialize_portfolio()
         self.kwargs = kwargs
+        self.periodes = 0
 
     @property
     def cash(self) -> float:

bbstrader/compat.py

@@ -4,7 +4,7 @@ import sys
 
 def setup_mock_metatrader():
     """Mock MetaTrader5 on Linux to prevent import errors."""
-    if platform.system() == "Linux":
+    if platform.system() != "Windows":
         from unittest.mock import MagicMock
 
         class Mock(MagicMock):

bbstrader/config.py

@@ -7,17 +7,15 @@ TERMINAL = "\\terminal64.exe"
 BASE_FOLDER = "C:\\Program Files\\"
 
 AMG_PATH = BASE_FOLDER + "Admirals Group MT5 Terminal" + TERMINAL
-XCB_PATH = BASE_FOLDER + "4xCube MT5 Terminal" + TERMINAL
-TML_PATH = BASE_FOLDER + "Trinota Markets MetaTrader 5 Terminal" + TERMINAL
 PGL_PATH = BASE_FOLDER + "Pepperstone MetaTrader 5" + TERMINAL
 FTMO_PATH = BASE_FOLDER + "FTMO MetaTrader 5" + TERMINAL
+JGM_PATH = BASE_FOLDER + "JustMarkets MetaTrader 5" + TERMINAL
 
 BROKERS_PATHS = {
     "AMG": AMG_PATH,
     "FTMO": FTMO_PATH,
-    "XCB": XCB_PATH,
-    "TML": TML_PATH,
     "PGL": PGL_PATH,
+    "JGM": JGM_PATH,
 }
 
 

bbstrader/core/utils.py

@@ -1,11 +1,100 @@
-from enum import Enum
+import configparser
+import importlib
+import importlib.util
+import os
 from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, List
+
+
+def load_module(file_path):
+    """Load a module from a file path.
+
+    Args:
+        file_path: Path to the file to load.
+
+    Returns:
+        The loaded module.
+    """
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(
+            f"Strategy file {file_path} not found. Please create it."
+        )
+    spec = importlib.util.spec_from_file_location("strategies", file_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def load_class(module, class_name, base_class):
+    """Load a class from a module.
+
+    Args:
+        module: The module to load the class from.
+        class_name: The name of the class to load.
+        base_class: The base class that the class must inherit from.
+    """
+    if not hasattr(module, class_name):
+        raise AttributeError(f"{class_name} not found in {module}")
+    class_ = getattr(module, class_name)
+    if not issubclass(class_, base_class):
+        raise TypeError(f"{class_name} must inherit from {base_class}.")
+    return class_
+
+
+def auto_convert(value):
+    """Convert string values to appropriate data types"""
+    if value.lower() in {"true", "false"}:  # Boolean
+        return value.lower() == "true"
+    elif value.lower() in {"none", "null"}:  # None
+        return None
+    elif value.isdigit():
+        return int(value)
+    try:
+        return float(value)
+    except ValueError:
+        return value
+
+
+def dict_from_ini(file_path, sections: str | List[str] = None) -> Dict[str, Any]:
+    """Reads an INI file and converts it to a dictionary with proper data types.
+
+    Args:
+        file_path: Path to the INI file to read.
+        sections: Optional list of sections to read from the INI file.
+
+    Returns:
+        A dictionary containing the INI file contents with proper data types.
+    """
+    config = configparser.ConfigParser()
+    config.read(file_path)
+
+    ini_dict = {}
+    for section in config.sections():
+        ini_dict[section] = {
+            key: auto_convert(value) for key, value in config.items(section)
+        }
+
+    if isinstance(sections, str):
+        try:
+            return ini_dict[sections]
+        except KeyError:
+            raise KeyError(f"{sections} not found in the {file_path} file")
+    if isinstance(sections, list):
+        sect_dict = {}
+        for section in sections:
+            try:
+                sect_dict[section] = ini_dict[section]
+            except KeyError:
+                raise KeyError(f"{section} not found in the {file_path} file")
+    return ini_dict
 
 
 class TradeAction(Enum):
     """
     An enumeration class for trade actions.
     """
+
     BUY = "LONG"
     LONG = "LONG"
     SELL = "SHORT"

bbstrader/metatrader/__init__.py

@@ -3,4 +3,5 @@ from bbstrader.metatrader.account import *  # noqa: F403
 from bbstrader.metatrader.rates import *  # noqa: F403
 from bbstrader.metatrader.risk import *  # noqa: F403
 from bbstrader.metatrader.trade import *  # noqa: F403
-from bbstrader.metatrader.utils import *  # noqa: F403
+from bbstrader.metatrader.utils import *  # noqa: F403*
+from bbstrader.metatrader.copier import *  # noqa: F403

bbstrader/metatrader/account.py

@@ -4,8 +4,6 @@ import urllib.request
 from datetime import datetime
 from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 
-from bbstrader import compat  # noqa: F401
-import MetaTrader5 as mt5
 import pandas as pd
 from currency_converter import SINGLE_DAY_ECB_URL, CurrencyConverter
 
@@ -24,14 +22,19 @@ from bbstrader.metatrader.utils import (
     raise_mt5_error,
 )
 
+try:
+    import MetaTrader5 as mt5
+except ImportError:
+    import bbstrader.compat  # noqa: F401
+
+
 __all__ = [
     "Account",
     "Broker",
     "AdmiralMarktsGroup",
     "JustGlobalMarkets",
-    "TrinotaMarkets",
-    "XCubeLimited",
     "PepperstoneGroupLimited",
+    "check_mt5_connection",
     "FTMO",
 ]
 
@@ -39,8 +42,6 @@ __BROKERS__ = {
     "AMG": "Admirals Group AS",
     "JGM": "Just Global Markets Ltd.",
     "FTMO": "FTMO S.R.O.",
-    "XCB": "4xCube Limited",
-    "TML": "Trinota Markets (Global) Limited",
     "PGL": "Pepperstone Group Limited",
 }
 
@@ -48,8 +49,6 @@ BROKERS_TIMEZONES = {
     "AMG": "Europe/Helsinki",
     "JGM": "Europe/Helsinki",
     "FTMO": "Europe/Helsinki",
-    "XCB": "Europe/Helsinki",
-    "TML": "Europe/Helsinki",
     "PGL": "Europe/Helsinki",
 }
 
@@ -68,11 +67,11 @@ _ADMIRAL_MARKETS_PRODUCTS_ = [
 ]
 _JUST_MARKETS_PRODUCTS_ = ["Stocks", "Crypto", "indices", "Commodities", "Forex"]
 
-
+SUPPORTED_BROKERS = [__BROKERS__[b] for b in {"AMG", "JGM", "FTMO"}]
 INIT_MSG = (
     f"\n* Ensure you have a good and stable internet connexion\n"
     f"* Ensure you have an activete MT5 terminal install on your machine\n"
-    f"* Ensure you have an active MT5 Account with {' or '.join(__BROKERS__.values())}\n"
+    f"* Ensure you have an active MT5 Account with {' or '.join(SUPPORTED_BROKERS)}\n"
     f"* If you want to trade {', '.join(_ADMIRAL_MARKETS_PRODUCTS_)}, See [{_ADMIRAL_MARKETS_URL_}]\n"
     f"* If you want to trade {', '.join(_JUST_MARKETS_PRODUCTS_)}, See [{_JUST_MARKETS_URL_}]\n"
     f"* If you are looking for a prop firm, See [{_FTMO_URL_}]\n"
@@ -189,7 +188,10 @@ def check_mt5_connection(**kwargs):
     except Exception:
         raise_mt5_error(INIT_MSG)
 
-
+def shutdown_mt5():
+    """Close the connection to the MetaTrader 5 terminal."""
+    mt5.shutdown()
+    
 class Broker(object):
     def __init__(self, name: str = None, **kwargs):
         if name is None:
@@ -242,24 +244,6 @@ class FTMO(Broker):
         return BROKERS_TIMEZONES["FTMO"]
 
 
-class XCubeLimited(Broker):
-    def __init__(self, **kwargs):
-        super().__init__("4xCube Limited", **kwargs)
-
-    @property
-    def timezone(self) -> str:
-        return BROKERS_TIMEZONES["XCB"]
-
-
-class TrinotaMarkets(Broker):
-    def __init__(self, **kwargs):
-        super().__init__("Trinota Markets (Global) Limited", **kwargs)
-
-    @property
-    def timezone(self) -> str:
-        return BROKERS_TIMEZONES["TML"]
-
-
 class PepperstoneGroupLimited(Broker):
     def __init__(self, **kwargs):
         super().__init__("Pepperstone Group Limited", **kwargs)
@@ -276,8 +260,6 @@ BROKERS: Dict[str, Broker] = {
     "FTMO": FTMO(),
     "AMG": AdmiralMarktsGroup(),
     "JGM": JustGlobalMarkets(),
-    "XCB": XCubeLimited(),
-    "TML": TrinotaMarkets(),
     "PGL": PepperstoneGroupLimited(),
 }
 
@@ -326,19 +308,25 @@ class Account(object):
 
         """
         check_mt5_connection(**kwargs)
-        self._check_brokers()
+        self._check_brokers(**kwargs)
 
-    def _check_brokers(self):
+    def _check_brokers(self, **kwargs):
+        if kwargs.get("copy", False):
+            return
         supported = BROKERS.copy()
         if self.broker not in supported.values():
             msg = (
                 f"{self.broker.name} is not currently supported broker for the Account() class\n"
-                f"Currently Supported brokers are: {', '.join([b.name for b in supported.values()])}\n"
+                f"Currently Supported brokers are: {', '.join(SUPPORTED_BROKERS)}\n"
                 f"For {supported['AMG'].name}, See [{amg_url}]\n"
                 f"For {supported['JGM'].name}, See [{jgm_url}]\n"
                 f"For {supported['FTMO'].name}, See [{ftmo_url}]\n"
             )
             raise InvalidBroker(message=msg)
+    
+    def shutdown(self):
+        """Close the connection to the MetaTrader 5 terminal."""
+        mt5.shutdown()
 
     @property
     def broker(self) -> Broker:
@@ -798,7 +786,9 @@ class Account(object):
             }
             return self._get_symbols_by_category("FX", category, fx_categories)
 
-    def get_stocks_from_country(self, country_code: str = "USA", etf=False) -> List[str]:
+    def get_stocks_from_country(
+        self, country_code: str = "USA", etf=False
+    ) -> List[str]:
         """
         Retrieves a list of stock symbols from a specific country.
 
@@ -990,7 +980,7 @@ class Account(object):
                 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"{e + msg}")
 
     def show_symbol_info(self, symbol: str):
         """
@@ -1036,7 +1026,7 @@ class Account(object):
                 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"{e + msg}")
 
     def show_tick_info(self, symbol: str):
         """