bbstrader 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

bbstrader/metatrader/trade.py

@@ -776,18 +776,19 @@ class Trade(RiskManagement):
         # Check the execution result
         pos = self._order_type()[type][1]
         addtionnal = f", SYMBOL={self.symbol}"
+        result = None
         try:
             self.check_order(request)
             result = self.send_order(request)
         except Exception as e:
-            msg = trade_retcode_message(result.retcode)
+            msg = trade_retcode_message(result.retcode)  if result else "N/A"
             LOGGER.error(f"Trade Order Request, {msg}{addtionnal}, {e}")
-        if result.retcode != Mt5.TRADE_RETCODE_DONE:
+        if result and result.retcode != Mt5.TRADE_RETCODE_DONE:
             if result.retcode == Mt5.TRADE_RETCODE_INVALID_FILL:  # 10030
                 for fill in FILLING_TYPE:
                     request["type_filling"] = fill
                     result = self.send_order(request)
-                    if result.retcode == Mt5.TRADE_RETCODE_DONE:
+                    if result and  result.retcode == Mt5.TRADE_RETCODE_DONE:
                         break
             elif result.retcode == Mt5.TRADE_RETCODE_INVALID_VOLUME:  # 10014
                 new_volume = int(request["volume"])
@@ -811,14 +812,14 @@ class Trade(RiskManagement):
                         self.check_order(request)
                         result = self.send_order(request)
                     except Exception as e:
-                        msg = trade_retcode_message(result.retcode)
+                        msg = trade_retcode_message(result.retcode)  if result else "N/A"
                         LOGGER.error(f"Trade Order Request, {msg}{addtionnal}, {e}")
-                    if result.retcode == Mt5.TRADE_RETCODE_DONE:
+                    if result and  result.retcode == Mt5.TRADE_RETCODE_DONE:
                         break
                     tries += 1
         # Print the result
-        if result.retcode == Mt5.TRADE_RETCODE_DONE:
-            msg = trade_retcode_message(result.retcode)
+        if result and  result.retcode == Mt5.TRADE_RETCODE_DONE:
+            msg = trade_retcode_message(result.retcode) 
             LOGGER.info(f"Trade Order {msg}{addtionnal}")
             if type != "BMKT" or type != "SMKT":
                 self.opened_orders.append(result.order)
@@ -854,7 +855,7 @@ class Trade(RiskManagement):
                             LOGGER.info(pos_info)
             return True
         else:
-            msg = trade_retcode_message(result.retcode)
+            msg = trade_retcode_message(result.retcode)  if result else "N/A"
             LOGGER.error(
                 f"Unable to Open Position, RETCODE={result.retcode}: {msg}{addtionnal}"
             )
@@ -1325,15 +1326,16 @@ class Trade(RiskManagement):
             request (dict): The request to set the stop loss to break even.
         """
         addtionnal = f", SYMBOL={self.symbol}"
+        result = None
         time.sleep(0.1)
         try:
             self.check_order(request)
             result = self.send_order(request)
         except Exception as e:
-            msg = trade_retcode_message(result.retcode)
+            msg = trade_retcode_message(result.retcode)   if result else "N/A"
             LOGGER.error(f"Break-Even Order Request, {msg}{addtionnal}, Error: {e}")
-        if result.retcode != Mt5.TRADE_RETCODE_DONE:
-            msg = trade_retcode_message(result.retcode)
+        if result and   result.retcode != Mt5.TRADE_RETCODE_DONE:
+            msg = trade_retcode_message(result.retcode)  
             if result.retcode != Mt5.TRADE_RETCODE_NO_CHANGES:
                 LOGGER.error(
                     f"Break-Even Order Request, Position: #{tiket}, RETCODE={result.retcode}: {msg}{addtionnal}"
@@ -1348,15 +1350,15 @@ class Trade(RiskManagement):
                         self.check_order(request)
                         result = self.send_order(request)
                     except Exception as e:
-                        msg = trade_retcode_message(result.retcode)
+                        msg = trade_retcode_message(result.retcode)   if result else "N/A"
                         LOGGER.error(
                             f"Break-Even Order Request, {msg}{addtionnal}, Error: {e}"
                         )
-                    if result.retcode == Mt5.TRADE_RETCODE_DONE:
+                    if result and   result.retcode == Mt5.TRADE_RETCODE_DONE:
                         break
                 tries += 1
-        if result.retcode == Mt5.TRADE_RETCODE_DONE:
-            msg = trade_retcode_message(result.retcode)
+        if result and   result.retcode == Mt5.TRADE_RETCODE_DONE:
+            msg = trade_retcode_message(result.retcode) 
             LOGGER.info(f"Break-Even Order {msg}{addtionnal}")
             info = f"Stop loss set to Break-even, Position: #{tiket}, Symbol: {self.symbol}, Price: @{round(price, 5)}"
             LOGGER.info(info)
@@ -1432,15 +1434,17 @@ class Trade(RiskManagement):
         """
         ticket = request[type]
         addtionnal = f", SYMBOL={self.symbol}"
+        result = None 
         try:
             self.check_order(request)
             result = self.send_order(request)
         except Exception as e:
-            msg = trade_retcode_message(result.retcode)
+            msg = trade_retcode_message(result.retcode) if result else "N/A"
             LOGGER.error(
-                f"Closing {type.capitalize()} Request, {msg}{addtionnal}, Error: {e}"
+                f"Closing {type.capitalize()} Request, RETCODE={msg}{addtionnal}, Error: {e}"
             )
-        if result.retcode != Mt5.TRADE_RETCODE_DONE:
+
+        if result and result.retcode != Mt5.TRADE_RETCODE_DONE:
             if result.retcode == Mt5.TRADE_RETCODE_INVALID_FILL:  # 10030
                 for fill in FILLING_TYPE:
                     request["type_filling"] = fill
@@ -1462,14 +1466,14 @@ class Trade(RiskManagement):
                         self.check_order(request)
                         result = self.send_order(request)
                     except Exception as e:
-                        msg = trade_retcode_message(result.retcode)
+                        msg = trade_retcode_message(result.retcode) if result else "N/A"
                         LOGGER.error(
                             f"Closing {type.capitalize()} Request, {msg}{addtionnal}, Error: {e}"
                         )
-                    if result.retcode == Mt5.TRADE_RETCODE_DONE:
+                    if result and result.retcode == Mt5.TRADE_RETCODE_DONE:
                         break
                     tries += 1
-        if result.retcode == Mt5.TRADE_RETCODE_DONE:
+        if result and result.retcode == Mt5.TRADE_RETCODE_DONE:
             msg = trade_retcode_message(result.retcode)
             LOGGER.info(f"Closing Order {msg}{addtionnal}")
             info = (
@@ -1504,7 +1508,7 @@ class Trade(RiskManagement):
         orders = self.get_orders(ticket=ticket) or []
         if len(orders) == 0:
             LOGGER.error(
-                f"Order #{ticket} not found, SYMBOL={self.symbol}, PRICE={round(price, 5)}"
+                f"Order #{ticket} not found, SYMBOL={self.symbol}, PRICE={round(price, 5) if price else 'N/A'}"
             )
             return
         order = orders[0]
@@ -1520,8 +1524,8 @@ class Trade(RiskManagement):
         result = self.send_order(request)
         if result.retcode == Mt5.TRADE_RETCODE_DONE:
             LOGGER.info(
-                f"Order #{ticket} modified, SYMBOL={self.symbol}, PRICE={round(price, 5)},"
-                f"SL={round(sl, 5)}, TP={round(tp, 5)}, STOP_LIMIT={round(stoplimit, 5)}"
+                f"Order #{ticket} modified, SYMBOL={self.symbol}, PRICE={round(request['price'], 5)},"
+                f"SL={round(request['sl'], 5)}, TP={round(request['tp'], 5)}, STOP_LIMIT={round(request['stoplimit'], 5)}"
             )
         else:
             msg = trade_retcode_message(result.retcode)

bbstrader/metatrader/utils.py

@@ -2,6 +2,8 @@ from datetime import datetime
 from enum import Enum
 from typing import NamedTuple, Optional
 
+import numpy as np
+
 try:
     import MetaTrader5 as MT5
 except ImportError:
@@ -28,6 +30,10 @@ __all__ = [
     "HistoryNotFound",
     "InvalidVersion",
     "AuthFailed",
+    "RateInfo",
+    "RateDtype",
+    "TickDtype",
+    "TickFlag",
     "UnsupportedMethod",
     "AutoTradingDisabled",
     "InternalFailSend",
@@ -285,6 +291,26 @@ class SymbolType(Enum):
     unknown = "UNKNOWN"  # Unknown or unsupported type
 
 
+TickDtype = np.dtype(
+    [
+        ("time", "<i8"),
+        ("bid", "<f8"),
+        ("ask", "<f8"),
+        ("last", "<f8"),
+        ("volume", "<u8"),
+        ("time_msc", "<i8"),
+        ("flags", "<u4"),
+        ("volume_real", "<f8"),
+    ]
+)
+
+TickFlag = {
+    "all": MT5.COPY_TICKS_ALL,
+    "info": MT5.COPY_TICKS_INFO,
+    "trade": MT5.COPY_TICKS_TRADE,
+}
+
+
 class TickInfo(NamedTuple):
     """
     Represents the last tick for the specified financial instrument.
@@ -308,6 +334,44 @@ class TickInfo(NamedTuple):
     volume_real: float
 
 
+RateDtype = np.dtype(
+    [
+        ("time", "<i8"),
+        ("open", "<f8"),
+        ("high", "<f8"),
+        ("low", "<f8"),
+        ("close", "<f8"),
+        ("tick_volume", "<u8"),
+        ("spread", "<i4"),
+        ("real_volume", "<u8"),
+    ]
+)
+
+
+class RateInfo(NamedTuple):
+    """
+    Reprents a candle (bar) for a specified period.
+    * time: Time in seconds since 1970.01.01 00:00
+    * open: Open price
+    * high: High price
+    * low: Low price
+    * close: Close price
+    * tick_volume: Tick volume
+    * spread: Spread value
+    * real_volume: Real volume
+
+    """
+
+    time: int
+    open: float
+    high: float
+    low: float
+    close: float
+    tick_volume: float
+    spread: int
+    real_volume: float
+
+
 class BookInfo(NamedTuple):
     """
     Represents the structure of a book.

bbstrader/models/factors.py

@@ -1,8 +1,9 @@
 from datetime import datetime
-from typing import Dict, List
+from typing import Dict, List, Literal
 
 import pandas as pd
 import yfinance as yf
+from loguru import logger
 
 from bbstrader.btengine.data import EODHDataHandler, FMPDataHandler
 from bbstrader.metatrader.rates import download_historical_data
@@ -16,6 +17,7 @@ __all__ = [
     "search_coint_candidate_pairs",
 ]
 
+
 def _download_and_process_data(source, tickers, start, end, tf, path, **kwargs):
     """Download and process data for a list of tickers from the specified source."""
     data_list = []
@@ -43,9 +45,7 @@ def _download_and_process_data(source, tickers, start, end, tf, path, **kwargs):
                 )
                 data = data.drop(columns=["adj_close"], axis=1)
             elif source in ["fmp", "eodhd"]:
-                handler_class = (
-                    FMPDataHandler if source == "fmp" else EODHDataHandler
-                )
+                handler_class = FMPDataHandler if source == "fmp" else EODHDataHandler
                 handler = handler_class(events=None, symbol_list=[ticker], **kwargs)
                 data = handler.data[ticker]
             else:
@@ -62,6 +62,7 @@ def _download_and_process_data(source, tickers, start, end, tf, path, **kwargs):
 
     return pd.concat(data_list)
 
+
 def _handle_date_range(start, end, window):
     """Handle start and end date generation."""
     if start is None or end is None:
@@ -73,6 +74,7 @@ def _handle_date_range(start, end, window):
         ).strftime("%Y-%m-%d")
     return start, end
 
+
 def _period_search(start, end, securities, candidates, window, npairs):
     if window < 3 or (pd.Timestamp(end) - pd.Timestamp(start)).days / 365 < 3:
         raise ValueError(
@@ -103,14 +105,11 @@ def _period_search(start, end, securities, candidates, window, npairs):
         )
     return top_pairs.head(npairs * 2)
 
+
 def _process_asset_data(securities, candidates, universe, rolling_window):
     """Process and select assets from the data."""
-    securities = select_assets(
-        securities, n=universe, rolling_window=rolling_window
-    )
-    candidates = select_assets(
-        candidates, n=universe, rolling_window=rolling_window
-    )
+    securities = select_assets(securities, n=universe, rolling_window=rolling_window)
+    candidates = select_assets(candidates, n=universe, rolling_window=rolling_window)
     return securities, candidates
 
 
@@ -121,7 +120,7 @@ def search_coint_candidate_pairs(
     end: str = None,
     period_search: bool = False,
     select: bool = True,
-    source: str = None,
+    source: Literal["yf", "mt5", "fmp", "eodhd"] = None,
     universe: int = 100,
     window: int = 2,
     rolling_window: int = None,
@@ -257,7 +256,9 @@ def search_coint_candidate_pairs(
         if period_search:
             start = securities.index.get_level_values("date").min()
             end = securities.index.get_level_values("date").max()
-            top_pairs = _period_search(start, end, securities, candidates, window, npairs)
+            top_pairs = _period_search(
+                start, end, securities, candidates, window, npairs
+            )
         else:
             top_pairs = find_cointegrated_pairs(
                 securities, candidates, n=npairs, coint=True
@@ -286,6 +287,10 @@ def search_coint_candidate_pairs(
         candidates_data = _download_and_process_data(
             source, candidates, start, end, tf, path, **kwargs
         )
+        if securities_data.empty or candidates_data.empty:
+            logger.error("No data found for candidates and securities")
+            return [] if select else pd.DataFrame()
+
         securities_data = securities_data.set_index(["ticker", "date"])
         candidates_data = candidates_data.set_index(["ticker", "date"])
         securities_data, candidates_data = _process_asset_data(
@@ -305,7 +310,6 @@ def search_coint_candidate_pairs(
             )
         else:
             return top_pairs
-
     else:
         msg = (
             "Invalid input. Either provide securities"

bbstrader/models/ml.py

@@ -1,5 +1,6 @@
 import os
 import warnings
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from itertools import product
 from time import time
 
@@ -7,7 +8,6 @@ import lightgbm as lgb
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
-import pandas_ta as ta
 import seaborn as sns
 import yfinance as yf
 from alphalens import performance as perf
@@ -22,15 +22,30 @@ from loguru import logger as log
 from scipy.stats import spearmanr
 from sklearn.preprocessing import LabelEncoder, StandardScaler
 
+try:
+    # This is to fix posix import error in pandas_ta
+    # On windows systems
+    import posix  # noqa: F401
+except (ImportError, Exception):
+    import bbstrader.compat  # noqa: F401
+
+import pandas_ta as ta
+
 warnings.filterwarnings("ignore")
 
 __all__ = ["OneStepTimeSeriesSplit", "MultipleTimeSeriesCV", "LightGBModel"]
 
 
 class OneStepTimeSeriesSplit:
-    __author__ = "Stefan Jansen"
-    """Generates tuples of train_idx, test_idx pairs
-    Assumes the index contains a level labeled 'date'"""
+    """
+    Generates tuples of train_idx, test_idx pairs
+    Assumes the index contains a level labeled 'date'
+
+    References
+    ----------
+    Stefan Jansen (2020). Machine Learning for Algorithmic Trading - Second Edition.
+    Chapter 12, Boosting Your Trading Strategy.
+    """
 
     def __init__(self, n_splits=3, test_period_length=1, shuffle=False):
         self.n_splits = n_splits
@@ -62,11 +77,15 @@ class OneStepTimeSeriesSplit:
 
 
 class MultipleTimeSeriesCV:
-    __author__ = "Stefan Jansen"
     """
     Generates tuples of train_idx, test_idx pairs
     Assumes the MultiIndex contains levels 'symbol' and 'date'
     purges overlapping outcomes
+
+    References
+    ----------
+    Stefan Jansen (2020). Machine Learning for Algorithmic Trading - Second Edition.
+    Chapter 12, Boosting Your Trading Strategy.
     """
 
     def __init__(
@@ -187,7 +206,7 @@ class LightGBModel(object):
         # Compute Bollinger Bands using pandas_ta
         bb = ta.bbands(close, length=20)
         return pd.DataFrame(
-            {"bb_high": bb["BBU_20_2.0"], "bb_low": bb["BBL_20_2.0"]}, index=close.index
+            {"bb_high": bb["BBU_20_2.0_2.0"], "bb_low": bb["BBL_20_2.0_2.0"]}, index=close.index
         )
 
     def _compute_atr(self, stock_data):
@@ -235,26 +254,29 @@ class LightGBModel(object):
         return prices
 
     def download_boosting_data(self, tickers, start, end=None):
-        data = []
-        for ticker in tickers:
-            try:
-                prices = yf.download(
-                    ticker,
-                    start=start,
-                    end=end,
-                    progress=False,
-                    multi_level_index=False,
-                    auto_adjust=True,
-                )
-                if prices.empty:
-                    continue
-                prices["symbol"] = ticker
-                data.append(prices)
-            except:  # noqa: E722
-                continue
-        data = pd.concat(data)
+        try:
+            data = yf.download(
+                tickers,
+                start=start,
+                end=end,
+                progress=False,
+                auto_adjust=True,
+                threads=True,
+            )
+            if data.empty:
+                return pd.DataFrame()
+
+            data = (
+                data.stack(level=1).rename_axis(["Date", "symbol"]).reset_index(level=1)
+            )
+        except Exception as e:
+            self.logger.error(f"An error occurred during data download: {e}")
+            return pd.DataFrame()
+
+        # The rest of the data processing is the same as the original function
         if "Adj Close" in data.columns:
             data = data.drop(columns=["Adj Close"])
+
         data = (
             data.rename(columns={s: s.lower().replace(" ", "_") for s in data.columns})
             .set_index("symbol", append=True)
@@ -265,17 +287,11 @@ class LightGBModel(object):
         return data
 
     def download_metadata(self, tickers):
-        def clean_text_column(series: pd.Series) -> pd.Series:
-            return (
-                series.str.lower()
-                # use regex=False for literal string replacements
-                .str.replace("-", "", regex=False)
-                .str.replace("&", "and", regex=False)
-                .str.replace(" ", "_", regex=False)
-                .str.replace("__", "_", regex=False)
-            )
+        """
+        Downloads metadata for multiple tickers concurrently using a thread pool.
+        """
 
-        metadata = [
+        METADATA_KEYS = [
             "industry",
             "sector",
             "exchange",
@@ -296,7 +312,7 @@ class LightGBModel(object):
             "marketCap",
         ]
 
-        columns = {
+        COLUMN_MAP = {
             "industry": "industry",
             "sector": "sector",
             "exchange": "exchange",
@@ -316,22 +332,53 @@ class LightGBModel(object):
             "askSize": "asksize",
             "marketCap": "marketcap",
         }
-        data = []
-        for symbol in tickers:
+
+        def _clean_text_column(series: pd.Series) -> pd.Series:
+            """Helper function to clean text columns."""
+            return (
+                series.str.lower()
+                .str.replace("-", "", regex=False)
+                .str.replace("&", "and", regex=False)
+                .str.replace(" ", "_", regex=False)
+                .str.replace("__", "_", regex=False)
+            )
+
+        def _fetch_single_ticker_info(symbol):
+            """Worker function to fetch and process info for one ticker."""
             try:
-                symbol_info = yf.Ticker(symbol).info
-            except:  # noqa: E722
-                continue
-            infos = {}
-            for info in metadata:
-                infos[info] = symbol_info.get(info)
-            data.append(infos)
+                ticker_info = yf.Ticker(symbol).info
+                return {key: ticker_info.get(key) for key in METADATA_KEYS}
+            except Exception:
+                return None
+
+        data = []
+        with ThreadPoolExecutor(max_workers=20) as executor:
+            future_to_ticker = {
+                executor.submit(_fetch_single_ticker_info, ticker): ticker
+                for ticker in tickers
+            }
+
+            for future in as_completed(future_to_ticker):
+                result = future.result()
+                if result:
+                    data.append(result)
+
+        if not data:
+            return pd.DataFrame()
+
         metadata = pd.DataFrame(data)
-        metadata = metadata.rename(columns=columns)
-        metadata.dyield = metadata.dyield.fillna(0)
-        metadata.sector = clean_text_column(metadata.sector)
-        metadata.industry = clean_text_column(metadata.industry)
-        metadata = metadata.set_index("symbol")
+        metadata = metadata.rename(columns=COLUMN_MAP)
+
+        if "dyield" in metadata.columns:
+            metadata.dyield = metadata.dyield.fillna(0)
+        if "sector" in metadata.columns:
+            metadata.sector = _clean_text_column(metadata.sector)
+        if "industry" in metadata.columns:
+            metadata.industry = _clean_text_column(metadata.industry)
+
+        if "symbol" in metadata.columns:
+            metadata = metadata.set_index("symbol")
+
         return metadata
 
     def _select_nlargest_liquidity_stocks(
@@ -1283,16 +1330,19 @@ class LightGBModel(object):
         except Exception as e:
             self.logger.error(f"Error getting last date: {e}")
         try:
-            days = 3 if now.weekday() == 0 else 1
-            time_delta = last_date - (now - pd.Timedelta(days=days)).normalize()
-            assert time_delta.days == days or last_date == now.normalize()
+            if now.weekday() == 0:  # Monday
+                expected_date = (now - pd.Timedelta(days=3)).normalize()  # last Friday
+            else:
+                expected_date = (now - pd.Timedelta(days=1)).normalize()  # yesterday
+
+            assert last_date == expected_date or last_date == now.normalize()
             return True
         except AssertionError:
             yesterday = (now - pd.Timedelta(days=1)).normalize()
             last_friday = (now - pd.Timedelta(days=now.weekday() + 3)).normalize()
             self.logger.debug(
-                f"Last date in predictions ({last_date}) is not equal to \
-                yesterday ({yesterday}) or last Friday ({last_friday})"
+                f"Last date in predictions ({last_date}) is not equal to "
+                f"yesterday ({yesterday}) or last Friday ({last_friday})"
             )
             return False
 

bbstrader/trading/execution.py

@@ -192,8 +192,8 @@ class Mt5ExecutionEngine:
         show_positions_orders: bool = False,
         iter_time: int | float = 5,
         use_trade_time: bool = True,
-        period: Literal["24/7", "day", "week", "month"] = "week",
-        period_end_action: Literal["break", "sleep"] = "break",
+        period: Literal["24/7", "day", "week", "month"] = "month",
+        period_end_action: Literal["break", "sleep"] = "sleep",
         closing_pnl: Optional[float] = None,
         trading_days: Optional[List[str]] = None,
         comment: Optional[str] = None,
@@ -631,12 +631,12 @@ class Mt5ExecutionEngine:
     def _update_risk(self, weights):
         try:
             check_mt5_connection(**self.kwargs)
-            if weights is not None:
+            if weights is not None and not all(v == 0 for v in weights.values()):
+                assert self.daily_risk is not None
                 for symbol in self.symbols:
                     if symbol not in weights:
                         continue
                     trade = self.trades_instances[symbol]
-                    assert self.daily_risk is not None
                     dailydd = round(weights[symbol] * self.daily_risk, 5)
                     trade.dailydd = dailydd
         except Exception as e:
@@ -930,7 +930,6 @@ class Mt5ExecutionEngine:
             return
 
         if not signals:
-            logger.info("No signals to process.")
             return
 
         # We want to create a temporary function that
@@ -994,14 +993,12 @@ class Mt5ExecutionEngine:
                 self._sleep()
                 self._handle_period_end_actions(today)
             except KeyboardInterrupt:
-                logger.info(
-                    f"Stopping Execution Engine for {self.STRATEGY} STRATEGY on {self.ACCOUNT} Account"
-                )
                 self.stop()
                 sys.exit(0)
             except Exception as e:
                 msg = f"Running Execution Engine, STRATEGY={self.STRATEGY} , ACCOUNT={self.ACCOUNT}"
                 self._print_exc(msg, e)
+                self._sleep()
 
     def stop(self):
         """Stops the execution engine."""
@@ -1038,6 +1035,10 @@ def RunMt5Engine(account_id: str, **kwargs):
             symbol_list, trades_instances, strategy_cls, **kwargs
         )
         engine.run()
+    except KeyboardInterrupt:
+        log.info(f"Execution engine for {account_id} interrupted by user")
+        engine.stop()
+        sys.exit(0)
     except Exception as e:
         log.exception(f"Error running execution engine for {account_id}: {e}")
     finally: