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

bbstrader/__main__.py

@@ -1,15 +1,29 @@
 import argparse
 import sys
+from enum import Enum
 
 import pyfiglet
 from colorama import Fore
 
 from bbstrader.btengine.scripts import backtest
+from bbstrader.core.scripts import send_news_feed
 from bbstrader.metatrader.scripts import copy_trades
 from bbstrader.trading.scripts import execute_strategy
 
-DESCRIPTION = "BBSTRADER"
-USAGE_TEXT = """
+
+class Module(Enum):
+    COPIER = "copier"
+    BACKTEST = "backtest"
+    EXECUTION = "execution"
+    NEWS_FEED = "news_feed"
+
+
+FONT = pyfiglet.figlet_format("BBSTRADER", font="big")
+
+
+def main():
+    DESCRIPTION = "BBSTRADER"
+    USAGE_TEXT = """
     Usage:
         python -m bbstrader --run <module> [options]
 
@@ -17,14 +31,10 @@ USAGE_TEXT = """
         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
+        news_feed: Send news feed from Coindesk to Telegram channel
     
     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)
     print(Fore.WHITE + "")
     parser = argparse.ArgumentParser(
@@ -39,12 +49,19 @@ def main():
     if ("-h" in sys.argv or "--help" in sys.argv) and args.run is None:
         print(Fore.WHITE + 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)
+
+    match args.run:
+        case Module.COPIER.value:
+            copy_trades(unknown)
+        case Module.BACKTEST.value:
+            backtest(unknown)
+        case Module.EXECUTION.value:
+            execute_strategy(unknown)
+        case Module.NEWS_FEED.value:
+            send_news_feed(unknown)
+        case _:
+            print(Fore.RED + f"Unknown module: {args.run}")
+            sys.exit(1)
 
 
 if __name__ == "__main__":

bbstrader/btengine/data.py

@@ -5,6 +5,7 @@ from queue import Queue
 from typing import Dict, List
 
 import numpy as np
+from numpy.typing import NDArray
 import pandas as pd
 import yfinance as yf
 from eodhd import APIClient
@@ -91,7 +92,7 @@ class DataHandler(metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def get_latest_bars_values(self, symbol, val_type, N=1) -> np.ndarray:
+    def get_latest_bars_values(self, symbol, val_type, N=1) -> NDArray:
         """
         Returns the last N bar values from the
         latest_symbol list, or N-k if less available.
@@ -301,7 +302,7 @@ class BaseCSVDataHandler(DataHandler):
                 )
                 raise
 
-    def get_latest_bars_values(self, symbol: str, val_type: str, N=1) -> np.ndarray:
+    def get_latest_bars_values(self, symbol: str, val_type: str, N=1) -> NDArray:
         """
         Returns the last N bar values from the
         latest_symbol list, or N-k if less available.
@@ -413,6 +414,7 @@ class MT5DataHandler(BaseCSVDataHandler):
         self.data_dir = kwargs.get("data_dir")
         self.symbol_list = symbol_list
         self.kwargs = kwargs
+        self.kwargs["backtest"] = True # Ensure backtest mode is set to avoid InvalidBroker errors
 
         csv_dir = self._download_and_cache_data(self.data_dir)
         super().__init__(

bbstrader/btengine/execution.py

@@ -7,6 +7,7 @@ from bbstrader.btengine.data import DataHandler
 from bbstrader.btengine.event import Events, FillEvent, OrderEvent
 from bbstrader.config import BBSTRADER_DIR
 from bbstrader.metatrader.account import Account
+from bbstrader.metatrader.utils import SymbolType
 
 __all__ = ["ExecutionHandler", "SimExecutionHandler", "MT5ExecutionHandler"]
 
@@ -71,6 +72,8 @@ class SimExecutionHandler(ExecutionHandler):
         self.events = events
         self.bardata = data
         self.logger = kwargs.get("logger") or logger
+        self.commissions = kwargs.get("commission")
+        self.exchange = kwargs.get("exchange", "ARCA")
 
     def execute_order(self, event: OrderEvent):
         """
@@ -85,11 +88,11 @@ class SimExecutionHandler(ExecutionHandler):
             fill_event = FillEvent(
                 timeindex=dtime,
                 symbol=event.symbol,
-                exchange="ARCA",
+                exchange=self.exchange,
                 quantity=event.quantity,
                 direction=event.direction,
                 fill_cost=None,
-                commission=None,
+                commission=self.commissions,
                 order=event.signal,
             )
             self.events.put(fill_event)
@@ -135,6 +138,8 @@ class MT5ExecutionHandler(ExecutionHandler):
         self.events = events
         self.bardata = data
         self.logger = kwargs.get("logger") or logger
+        self.commissions = kwargs.get("commission")
+        self.exchange = kwargs.get("exchange", "MT5")
         self.__account = Account(**kwargs)
 
     def _calculate_lot(self, symbol, quantity, price):
@@ -145,9 +150,13 @@ class MT5ExecutionHandler(ExecutionHandler):
         lot = (quantity * price) / (contract_size * price)
         if contract_size == 1:
             lot = quantity
-        if symbol_type in ["COMD", "FUT", "CRYPTO"] and contract_size > 1:
+        if (
+            symbol_type
+            in (SymbolType.COMMODITIES, SymbolType.FUTURES, SymbolType.CRYPTO)
+            and contract_size > 1
+        ):
             lot = quantity / contract_size
-        if symbol_type == "FX":
+        if symbol_type == SymbolType.FOREX:
             lot = quantity * price / contract_size
         return self._check_lot(symbol, lot)
 
@@ -161,17 +170,17 @@ class MT5ExecutionHandler(ExecutionHandler):
 
     def _estimate_total_fees(self, symbol, lot, qty, price):
         symbol_type = self.__account.get_symbol_type(symbol)
-        if symbol_type in ["STK", "ETF"]:
+        if symbol_type in (SymbolType.STOCKS, SymbolType.ETFs):
             return self._estimate_stock_commission(symbol, qty, price)
-        elif symbol_type == "FX":
+        elif symbol_type == SymbolType.FOREX:
             return self._estimate_forex_commission(lot)
-        elif symbol_type == "COMD":
+        elif symbol_type == SymbolType.COMMODITIES:
             return self._estimate_commodity_commission(lot)
-        elif symbol_type == "IDX":
+        elif symbol_type == SymbolType.INDICES:
             return self._estimate_index_commission(lot)
-        elif symbol_type == "FUT":
+        elif symbol_type == SymbolType.FUTURES:
             return self._estimate_futures_commission()
-        elif symbol_type == "CRYPTO":
+        elif symbol_type == SymbolType.CRYPTO:
             return self._estimate_crypto_commission()
         else:
             return 0.0
@@ -187,7 +196,7 @@ class MT5ExecutionHandler(ExecutionHandler):
         eu_asia_cm = 0.0015  # percent
         if (
             symbol in self.__account.get_stocks_from_country("USA")
-            or self.__account.get_symbol_type(symbol) == "ETF"
+            or self.__account.get_symbol_type(symbol) == SymbolType.ETFs
             and self.__account.get_currency_rates(symbol)["mc"] == "USD"
         ):
             return max(min_com, qty * us_com)
@@ -195,7 +204,7 @@ class MT5ExecutionHandler(ExecutionHandler):
             symbol in self.__account.get_stocks_from_country("GBR")
             or symbol in self.__account.get_stocks_from_country("FRA")
             or symbol in self.__account.get_stocks_from_country("DEU")
-            or self.__account.get_symbol_type(symbol) == "ETF"
+            or self.__account.get_symbol_type(symbol) == SymbolType.ETFs
             and self.__account.get_currency_rates(symbol)["mc"] in ["GBP", "EUR"]
         ):
             return max(min_com, qty * price * ger_fr_uk_cm)
@@ -241,14 +250,15 @@ class MT5ExecutionHandler(ExecutionHandler):
             lot = self._calculate_lot(symbol, quantity, price)
             fees = self._estimate_total_fees(symbol, lot, quantity, price)
             dtime = self.bardata.get_latest_bar_datetime(symbol)
+            commission = self.commissions or fees
             fill_event = FillEvent(
                 timeindex=dtime,
                 symbol=symbol,
-                exchange="MT5",
+                exchange=self.exchange,
                 quantity=quantity,
                 direction=direction,
                 fill_cost=None,
-                commission=fees,
+                commission=commission,
                 order=event.signal,
             )
             self.events.put(fill_event)

bbstrader/btengine/strategy.py

@@ -17,10 +17,12 @@ from bbstrader.metatrader.account import (
     AdmiralMarktsGroup,
     PepperstoneGroupLimited,
 )
+from bbstrader.metatrader.utils import SymbolType
 from bbstrader.metatrader.rates import Rates
-from bbstrader.metatrader.trade import TradeSignal
+from bbstrader.metatrader.trade import TradeSignal, TradingMode
 from bbstrader.models.optimization import optimized_weights
 
+
 __all__ = ["Strategy", "MT5Strategy"]
 
 logger.add(
@@ -76,7 +78,7 @@ class MT5Strategy(Strategy):
         events: Queue = None,
         symbol_list: List[str] = None,
         bars: DataHandler = None,
-        mode: str = None,
+        mode: TradingMode = None,
         **kwargs,
     ):
         """
@@ -86,7 +88,7 @@ class MT5Strategy(Strategy):
             events : The event queue.
             symbol_list : The list of symbols for the strategy.
             bars : The data handler object.
-            mode : The mode of operation for the strategy (backtest or live).
+            mode (TradingMode): The mode of operation for the strategy.
             **kwargs : Additional keyword arguments for other classes (e.g, Portfolio, ExecutionHandler).
                 - max_trades : The maximum number of trades allowed per symbol.
                 - time_frame : The time frame for the strategy.
@@ -101,33 +103,49 @@ class MT5Strategy(Strategy):
         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") or logger
-        if self.mode == "backtest":
+        if self.mode == TradingMode.BACKTEST:
             self._initialize_portfolio()
         self.kwargs = kwargs
         self.periodes = 0
+    
+    @property 
+    def account(self):
+        return Account(**self.kwargs)
 
     @property
     def cash(self) -> float:
+        if self.mode == TradingMode.LIVE:
+            return self.account.balance
         return self._porfolio_value
 
     @cash.setter
     def cash(self, value):
+        if self.mode == TradingMode.LIVE:
+            raise ValueError("Cannot set the account cash in live mode")
         self._porfolio_value = value
 
     @property
-    def orders(self) -> Dict[str, Dict[str, List[SignalEvent]]]:
+    def orders(self):
+        if self.mode == TradingMode.LIVE:
+            return self.account.get_orders()
         return self._orders
 
     @property
     def trades(self) -> Dict[str, Dict[str, int]]:
+        if self.mode == TradingMode.LIVE:
+            raise ValueError("Cannot call this methode in live mode")
         return self._trades
 
     @property
-    def positions(self) -> Dict[str, Dict[str, int | float]]:
+    def positions(self):
+        if self.mode == TradingMode.LIVE:
+            return self.account.get_positions()
         return self._positions
 
     @property
     def holdings(self) -> Dict[str, float]:
+        if self.mode == TradingMode.LIVE:
+            raise ValueError("Cannot call this methode in live mode")
         return self._holdings
 
     def _check_risk_budget(self, **kwargs):
@@ -606,7 +624,7 @@ class MT5Strategy(Strategy):
         value_type: str = "returns",
         array: bool = True,
         bars: DataHandler = None,
-        mode: Literal["backtest", "live"] = "backtest",
+        mode: TradingMode = TradingMode.BACKTEST,
         tf: str = "D1",
         error: Literal["ignore", "raise"] = None,
     ) -> Dict[str, np.ndarray | pd.Series] | None:
@@ -634,7 +652,7 @@ class MT5Strategy(Strategy):
         if mode not in ["backtest", "live"]:
             raise ValueError("Mode must be either backtest or live.")
         asset_values = {}
-        if mode == "backtest":
+        if mode == TradingMode.BACKTEST:
             if bars is None:
                 raise ValueError("DataHandler is required for backtest mode.")
             for asset in symbol_list:
@@ -644,11 +662,11 @@ class MT5Strategy(Strategy):
                 else:
                     values = bars.get_latest_bars(asset, N=window)
                     asset_values[asset] = getattr(values, value_type)
-        elif mode == "live":
+        elif mode == TradingMode.LIVE:
             for asset in symbol_list:
                 rates = Rates(asset, timeframe=tf, count=window + 1, **self.kwargs)
                 if array:
-                    values = getattr(rates, value_type).values
+                    values = getattr(rates, value_type).to_numpy()
                     asset_values[asset] = values[~np.isnan(values)]
                 else:
                     values = getattr(rates, value_type)
@@ -704,7 +722,7 @@ class MT5Strategy(Strategy):
         Returns:
             bool : True if there are open positions, False otherwise
         """
-        account = account or Account(**self.kwargs)
+        account = account or self.account
         positions = account.get_positions(symbol=symbol)
         if positions is not None:
             open_positions = [
@@ -730,7 +748,7 @@ class MT5Strategy(Strategy):
         Returns:
             prices : numpy array of buy or sell prices for open positions if any or an empty array.
         """
-        account = account or Account(**self.kwargs)
+        account = account or self.account
         positions = account.get_positions(symbol=symbol)
         if positions is not None:
             prices = np.array(
@@ -778,21 +796,21 @@ class MT5Strategy(Strategy):
         return dt_to
 
     @staticmethod
-    def get_mt5_equivalent(symbols, type="STK", **kwargs) -> List[str]:
+    def get_mt5_equivalent(symbols, symbol_type: str | SymbolType = SymbolType.STOCKS, **kwargs) -> List[str]:
         """
         Get the MetaTrader 5 equivalent symbols for the symbols in the list.
         This method is used to get the symbols that are available on the MetaTrader 5 platform.
 
         Args:
             symbols : The list of symbols to get the MetaTrader 5 equivalent symbols for.
-            type : The type of symbols to get (e.g., STK, CFD, etc.).
+            symbol_type : The type of symbols to get (See `bbstrader.metatrader.utils.SymbolType`).
             **kwargs : Additional keyword arguments for the `bbstrader.metatrader.Account` object.
 
         Returns:
             mt5_equivalent : The MetaTrader 5 equivalent symbols for the symbols in the list.
         """
         account = Account(**kwargs)
-        mt5_symbols = account.get_symbols(symbol_type=type)
+        mt5_symbols = account.get_symbols(symbol_type=symbol_type)
         mt5_equivalent = []
         if account.broker == AdmiralMarktsGroup():
             for s in mt5_symbols:

bbstrader/core/data.py

@@ -198,7 +198,7 @@ class FmpNews(object):
 class FinancialNews(object):
     """
     The FinancialNews class provides methods to fetch financial news, articles, and discussions
-    from various sources such as Yahoo Finance, Google Finance, Reddit, and Twitter.
+    from various sources such as Yahoo Finance, Google Finance, Reddit, Coindesk and Twitter.
     It also supports retrieving news using Financial Modeling Prep (FMP).
 
     """

bbstrader/core/scripts.py

@@ -0,0 +1,130 @@
+import argparse
+import asyncio
+import sys
+import textwrap
+import time
+from datetime import datetime, timedelta
+
+import nltk
+from loguru import logger
+from sumy.nlp.tokenizers import Tokenizer
+from sumy.parsers.plaintext import PlaintextParser
+from sumy.summarizers.text_rank import TextRankSummarizer
+
+from bbstrader.core.data import FinancialNews
+from bbstrader.trading.utils import send_telegram_message
+
+
+def summarize_text(text, sentences_count=5):
+    """
+    Generate a summary using TextRank algorithm.
+    """
+    parser = PlaintextParser.from_string(text, Tokenizer("english"))
+    summarizer = TextRankSummarizer()
+    summary = summarizer(parser.document, sentences_count)
+    return " ".join(str(sentence) for sentence in summary)
+
+
+def format_article_for_telegram(article: dict) -> str:
+    if not all(
+        k in article
+        for k in (
+            "body",
+            "title",
+            "published_on",
+            "sentiment",
+            "keywords",
+            "keywords",
+            "url",
+        )
+    ):
+        return ""
+    summary = summarize_text(article["body"])
+    text = (
+        f"📰 {article['title']}\n"
+        f"Published Date: {article['published_on']}\n"
+        f"Sentiment: {article['sentiment']}\n"
+        f"Status: {article['status']}\n"
+        f"Keywords: {article['keywords']}\n\n"
+        f"🔍 Summary\n"
+        f"{textwrap.fill(summary, width=80)}"
+        f"\n\n👉 Visit {article['url']} for full article."
+    )
+    return text
+
+
+async def send_articles(articles: dict, token: str, id: str, interval=15):
+    for article in articles:
+        if article["published_on"] >= datetime.now() - timedelta(minutes=interval):
+            article["published_on"] = article.get("published_on").strftime(
+                "%Y-%m-%d %H:%M:%S"
+            )
+            message = format_article_for_telegram(article)
+            if message == "":
+                return
+            await send_telegram_message(token, id, text=message)
+
+
+def send_news_feed(unknown):
+    HELP_MSG = """
+    Send news feed from Coindesk to Telegram channel.
+    This script fetches the latest news articles from Coindesk, summarizes them,
+    and sends them to a specified Telegram channel at regular intervals.
+
+    Usage:
+        python -m bbstrader --run news_feed [options]
+
+    Options:
+        -q, --query: The news to look for (default: "")
+        -t, --token: Telegram bot token
+        -I, --id: Telegram Chat id
+        -i, --interval: Interval in minutes to fetch news (default: 15)
+
+    Note:
+        The script will run indefinitely, fetching news every 15 minutes.
+        Use Ctrl+C to stop the script.
+    """
+
+    if "-h" in unknown or "--help" in unknown:
+        print(HELP_MSG)
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-q", "--query", type=str, default="", help="The news to look for"
+    )
+    parser.add_argument(
+        "-t",
+        "--token",
+        type=str,
+        required=True,
+        help="Telegram bot token",
+    )
+    parser.add_argument("-I", "--id", type=str, required=True, help="Telegram Chat id")
+    parser.add_argument(
+        "-i",
+        "--interval",
+        type=int,
+        default=15,
+        help="Interval in minutes to fetch news (default: 15)",
+    )
+    args = parser.parse_args(unknown)
+
+    nltk.download("punkt", quiet=True)
+    news = FinancialNews()
+    logger.info(
+        f"Starting the News Feed on {args.interval} minutes"
+    )
+    while True:
+        try:
+            articles = news.get_coindesk_news(query=args.query)
+            if len(articles) == 0:
+                time.sleep(args.interval * 60)
+                continue
+            asyncio.run(send_articles(articles, args.token, args.id))
+            time.sleep(args.interval * 60)
+        except KeyboardInterrupt:
+            logger.info("Stopping the News Feed ...")
+            exit(0)
+        except Exception as e:
+            logger.error(e)