bbstrader 0.2.91__py3-none-any.whl → 0.2.93__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
+    
+    python -m bbstrader --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

@@ -175,9 +175,9 @@ class BaseCSVDataHandler(DataHandler):
         new_names = self.columns or default_names
         new_names = [name.strip().lower().replace(" ", "_") for name in new_names]
         self.columns = new_names
-        assert (
-            "adj_close" in new_names or "close" in new_names
-        ), "Column names must contain 'Adj Close' and 'Close' or adj_close and close"
+        assert "adj_close" in new_names or "close" in new_names, (
+            "Column names must contain 'Adj Close' and 'Close' or adj_close and close"
+        )
         comb_index = None
         for s in self.symbol_list:
             # Load the CSV file with no header information,
@@ -207,7 +207,9 @@ class BaseCSVDataHandler(DataHandler):
                 self.columns.append("adj_close")
                 self.symbol_data[s]["adj_close"] = self.symbol_data[s]["close"]
             self.symbol_data[s]["returns"] = (
-                self.symbol_data[s]["adj_close" if "adj_close" in new_names else "close"]
+                self.symbol_data[s][
+                    "adj_close" if "adj_close" in new_names else "close"
+                ]
                 .pct_change()
                 .dropna()
             )
@@ -362,7 +364,7 @@ class CSVDataHandler(BaseCSVDataHandler):
 
         """
         csv_dir = kwargs.get("csv_dir")
-        csv_dir = csv_dir or BBSTRADER_DIR / "csv_data"
+        csv_dir = csv_dir or BBSTRADER_DIR / "data" / "csv_data"
         super().__init__(
             events,
             symbol_list,
@@ -422,7 +424,7 @@ class MT5DataHandler(BaseCSVDataHandler):
         )
 
     def _download_and_cache_data(self, cache_dir: str):
-        data_dir = cache_dir or BBSTRADER_DIR / "mt5" / self.tf
+        data_dir = cache_dir or BBSTRADER_DIR / "data" / "mt5" / self.tf
         data_dir.mkdir(parents=True, exist_ok=True)
         for symbol in self.symbol_list:
             try:
@@ -486,7 +488,7 @@ class YFDataHandler(BaseCSVDataHandler):
 
     def _download_and_cache_data(self, cache_dir: str):
         """Downloads and caches historical data as CSV files."""
-        cache_dir = cache_dir or BBSTRADER_DIR / "yfinance" / "daily"
+        cache_dir = cache_dir or BBSTRADER_DIR / "data" / "yfinance" / "daily"
         os.makedirs(cache_dir, exist_ok=True)
         for symbol in self.symbol_list:
             filepath = os.path.join(cache_dir, f"{symbol}.csv")
@@ -496,6 +498,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:
@@ -597,7 +600,7 @@ class EODHDataHandler(BaseCSVDataHandler):
 
     def _download_and_cache_data(self, cache_dir: str):
         """Downloads and caches historical data as CSV files."""
-        cache_dir = cache_dir or BBSTRADER_DIR / "eodhd" / self.period
+        cache_dir = cache_dir or BBSTRADER_DIR / "data" / "eodhd" / self.period
         os.makedirs(cache_dir, exist_ok=True)
         for symbol in self.symbol_list:
             filepath = os.path.join(cache_dir, f"{symbol}.csv")
@@ -698,7 +701,7 @@ class FMPDataHandler(BaseCSVDataHandler):
 
     def _download_and_cache_data(self, cache_dir: str):
         """Downloads and caches historical data as CSV files."""
-        cache_dir = cache_dir or BBSTRADER_DIR / "fmp" / self.period
+        cache_dir = cache_dir or BBSTRADER_DIR / "data" / "fmp" / self.period
         os.makedirs(cache_dir, exist_ok=True)
         for symbol in self.symbol_list:
             filepath = os.path.join(cache_dir, f"{symbol}.csv")

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

@@ -3,8 +3,8 @@ import sys
 
 
 def setup_mock_metatrader():
-    """Mock MetaTrader5 on Linux to prevent import errors."""
-    if platform.system() == "Linux":
+    """Mock MetaTrader5 on Linux and MacOS to prevent import errors."""
+    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("bbstrader.cli", 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(interpolation=None)
+    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