bbstrader 2.0.7__tar.gz → 2.0.8__tar.gz

{bbstrader-2.0.7 → bbstrader-2.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bbstrader
-Version: 2.0.7
+Version: 2.0.8
 Summary: Simplified Investment & Trading Toolkit with Python & C++
 Keywords: Finance,Toolkit,Financial,Analysis,Fundamental,Quantitative,Database,Equities,Currencies,Economics,ETFs,Funds,Indices,Moneymarkets,Commodities,Futures,CFDs,Derivatives,Trading,Investing,Portfolio,Optimization,Performance
 Author-Email: Bertin Balouki SIMYELI <bertin@bbs-trading.com>
@@ -28,6 +28,7 @@ Requires-Dist: ipython>=9.5.0
 Requires-Dist: nltk>=3.9.1
 Requires-Dist: notify_py>=0.3.43
 Requires-Dist: numpy>=2.2.6
+Requires-Dist: plotly>=5.24.1
 Requires-Dist: praw>=7.8.1
 Requires-Dist: pybind11>=3.0.1
 Requires-Dist: pyfiglet>=1.0.4

bbstrader-2.0.8/VERSION.txt

@@ -0,0 +1 @@
+2.0.8

{bbstrader-2.0.7 → bbstrader-2.0.8}/pyproject.toml

@@ -17,6 +17,7 @@ dependencies = [
     "nltk>=3.9.1",
     "notify_py>=0.3.43",
     "numpy>=2.2.6",
+    "plotly>=5.24.1",
     "praw>=7.8.1",
     "pybind11>=3.0.1",
     "pyfiglet>=1.0.4",

{bbstrader-2.0.7 → bbstrader-2.0.8}/src/bbstrader/api/handlers.py

@@ -21,6 +21,7 @@ try:
     import MetaTrader5 as mt5
 except ImportError:
     import bbstrader.compat  # noqa: F401
+    import MetaTrader5 as mt5
 
 
 def _convert_obj(obj, obj_type):

{bbstrader-2.0.7 → bbstrader-2.0.8}/src/bbstrader/btengine/performance.py

@@ -17,6 +17,10 @@ __all__ = [
     "plot_performance",
     "create_sharpe_ratio",
     "create_sortino_ratio",
+    "create_omega_ratio",
+    "create_calmar_ratio",
+    "create_tail_ratio",
+    "calculate_risk_metrics",
     "plot_returns_and_dd",
     "plot_monthly_yearly_returns",
     "show_qs_stats",
@@ -111,6 +115,72 @@ def create_sortino_ratio(returns: pd.Series, periods: int = 252) -> float:
     return qs.stats.sortino(returns, periods=periods)
 
 
+def create_omega_ratio(
+    returns: pd.Series, periods: int = 252, rf: float = 0.0
+) -> float:
+    """
+    Create the Omega ratio for the strategy.
+
+    Args:
+        returns : A pandas Series representing period percentage returns.
+        periods (int): Daily (252), Hourly (252*6.5), Minutely(252*6.5*60) etc.
+        rf (float): Risk-free rate.
+
+    Returns:
+        float: Omega ratio
+    """
+    return qs.stats.omega(returns, rf=rf)
+
+
+def create_calmar_ratio(returns: pd.Series, periods: int = 252) -> float:
+    """
+    Create the Calmar ratio for the strategy.
+
+    Args:
+        returns : A pandas Series representing period percentage returns.
+        periods (int): Daily (252), Hourly (252*6.5), Minutely(252*6.5*60) etc.
+
+    Returns:
+        float: Calmar ratio
+    """
+    return qs.stats.calmar(returns)
+
+
+def create_tail_ratio(returns: pd.Series) -> float:
+    """
+    Create the Tail ratio for the strategy.
+
+    Args:
+        returns : A pandas Series representing period percentage returns.
+
+    Returns:
+        float: Tail ratio
+    """
+    return qs.stats.tail_ratio(returns)
+
+
+def calculate_risk_metrics(
+    returns: pd.Series, benchmark_returns: pd.Series, periods: int = 252
+) -> Dict[str, float]:
+    """
+    Calculate Alpha, Beta and Volatility for the strategy.
+
+    Args:
+        returns : A pandas Series representing period percentage returns.
+        benchmark_returns : A pandas Series representing benchmark period percentage returns.
+        periods (int): Daily (252), Hourly (252*6.5), Minutely(252*6.5*60) etc.
+
+    Returns:
+        Dict[str, float]: Alpha, Beta, Volatility
+    """
+    g_beta = qs.stats.greeks(returns, benchmark_returns)
+    alpha = g_beta["alpha"]
+    beta = g_beta["beta"]
+    volatility = qs.stats.volatility(returns, periods=periods)
+
+    return {"alpha": alpha, "beta": beta, "volatility": volatility}
+
+
 def create_drawdowns(pnl: pd.Series) -> Tuple[pd.Series, float, float]:
     """
     Calculate the largest peak-to-trough drawdown of the PnL curve
@@ -125,6 +195,8 @@ def create_drawdowns(pnl: pd.Series) -> Tuple[pd.Series, float, float]:
     """
     # Calculate the cumulative returns curve
     # and set up the High Water Mark
+    if pnl.empty:
+        return pd.Series(dtype=float), 0.0, 0.0
     hwm = pd.Series(index=pnl.index)
     hwm.iloc[0] = 0
 
@@ -139,7 +211,9 @@ def create_drawdowns(pnl: pd.Series) -> Tuple[pd.Series, float, float]:
         drawdown.iloc[t] = hwm.iloc[t] - pnl.iloc[t]
         duration.iloc[t] = 0 if drawdown.iloc[t] == 0 else duration.iloc[t - 1] + 1
 
-    return drawdown, drawdown.max(), duration.max()
+    max_drawdown = drawdown.max() if not drawdown.empty else 0.0
+    max_duration = duration.max() if not duration.empty else 0.0
+    return drawdown, max_drawdown, max_duration
 
 
 def plot_performance(df: pd.DataFrame, title: str) -> None:

{bbstrader-2.0.7 → bbstrader-2.0.8}/src/bbstrader/metatrader/broker.py

@@ -11,6 +11,7 @@ try:
     import MetaTrader5 as mt5
 except ImportError:
     import bbstrader.compat  # noqa: F401
+    import MetaTrader5 as mt5
 
 COUNTRIES_STOCKS = {
     "USA": r"\b(US|USA)\b",

{bbstrader-2.0.7 → bbstrader-2.0.8}/src/bbstrader/metatrader/copier.py

@@ -22,6 +22,7 @@ try:
     import MetaTrader5 as Mt5
 except ImportError:
     import bbstrader.compat  # noqa: F401
+    import MetaTrader5 as Mt5
 
 
 __all__ = [

{bbstrader-2.0.7 → bbstrader-2.0.8}/src/bbstrader/metatrader/rates.py

@@ -12,6 +12,7 @@ try:
     import MetaTrader5 as Mt5
 except ImportError:
     import bbstrader.compat  # noqa: F401
+    import MetaTrader5 as Mt5
 
 
 __all__ = [

{bbstrader-2.0.7 → bbstrader-2.0.8}/src/bbstrader/metatrader/risk.py

@@ -14,6 +14,7 @@ try:
     import MetaTrader5 as mt5
 except ImportError:
     import bbstrader.compat  # noqa: F401
+    import MetaTrader5 as mt5
 
 logger.add(
     f"{BBSTRADER_DIR}/logs/trade.log",

{bbstrader-2.0.7 → bbstrader-2.0.8}/src/bbstrader/metatrader/trade.py

@@ -22,6 +22,7 @@ try:
     import MetaTrader5 as Mt5
 except ImportError:
     import bbstrader.compat  # noqa: F401
+    import MetaTrader5 as Mt5
 
 __all__ = [
     "Trade",

{bbstrader-2.0.7 → bbstrader-2.0.8}/src/bbstrader/metatrader/utils.py

@@ -7,6 +7,7 @@ try:
     import MetaTrader5 as MT5
 except ImportError:
     import bbstrader.compat  # noqa: F401
+    import MetaTrader5 as MT5
 
 
 __all__ = [

{bbstrader-2.0.7 → bbstrader-2.0.8}/src/bbstrader/models/optimization.py

@@ -3,30 +3,36 @@ import warnings
 from pypfopt import expected_returns, risk_models
 from pypfopt.efficient_frontier import EfficientFrontier
 from pypfopt.hierarchical_portfolio import HRPOpt
+from pypfopt.black_litterman import BlackLittermanModel
 
 __all__ = [
     "markowitz_weights",
     "hierarchical_risk_parity",
+    "black_litterman_weights",
     "equal_weighted",
     "optimized_weights",
 ]
 
 
-def markowitz_weights(prices=None, rfr=0.0, freq=252):
+def markowitz_weights(prices=None, rfr=0.0, freq=252, min_vol=False):
     """
-    Calculates optimal portfolio weights using Markowitz's mean-variance optimization (Max Sharpe Ratio) with multiple solvers.
+    Calculates optimal portfolio weights using Markowitz's mean-variance optimization (Max Sharpe Ratio or Min Volatility) with multiple solvers.
 
     Parameters
     ----------
     prices : pd.DataFrame, optional
         Price data for assets, where rows represent time periods and columns represent assets.
+    rfr : float, optional
+        Risk-free rate (default is 0.0).
     freq : int, optional
         Frequency of the data, such as 252 for daily returns in a year (default is 252).
+    min_vol : bool, optional
+        If True, optimizes for minimum volatility instead of maximum Sharpe ratio (default is False).
 
     Returns
     -------
     dict
-        Dictionary containing the optimal asset weights for maximizing the Sharpe ratio, normalized to sum to 1.
+        Dictionary containing the optimal asset weights for maximizing the Sharpe ratio or minimizing volatility, normalized to sum to 1.
 
     Notes
     -----
@@ -53,10 +59,15 @@ def markowitz_weights(prices=None, rfr=0.0, freq=252):
             solver=solver,
         )
         try:
-            ef.max_sharpe(risk_free_rate=rfr)
+            if min_vol:
+                ef.min_volatility()
+            else:
+                ef.max_sharpe(risk_free_rate=rfr)
             return ef.clean_weights()
         except Exception as e:
             print(f"Solver {solver} failed with error: {e}")
+    # Default to equal weighted if all solvers fail
+    return equal_weighted(prices=prices)
 
 
 def hierarchical_risk_parity(prices=None, returns=None, freq=252):
@@ -140,7 +151,66 @@ def equal_weighted(prices=None, returns=None, round_digits=5):
     return {col: round(1 / n, round_digits) for col in columns}
 
 
-def optimized_weights(prices=None, returns=None, rfr=0.0, freq=252, method="equal"):
+def black_litterman_weights(
+    prices=None,
+    rfr=0.0,
+    freq=252,
+    views=None,
+    view_confidences=None,
+    pi=None,
+    market_caps=None,
+):
+    """
+    Computes portfolio weights using the Black-Litterman model.
+
+    Parameters
+    ----------
+    prices : pd.DataFrame
+        Price data for assets.
+    rfr : float, optional
+        Risk-free rate (default is 0.0).
+    freq : int, optional
+        Frequency of the data (default is 252).
+    views : dict, optional
+        Investor's views on asset returns.
+    view_confidences : list or np.array, optional
+        Confidence levels for each view.
+    pi : pd.Series, optional
+        Market-implied prior returns.
+    market_caps : pd.Series, optional
+        Market capitalization of assets.
+
+    Returns
+    -------
+    dict
+        Optimal asset weights based on the Black-Litterman model.
+    """
+    cov_matrix = risk_models.sample_cov(prices, frequency=freq)
+    if pi is None:
+        if market_caps is not None:
+            # If market caps are provided, we can use them to compute the prior
+            # This requires a benchmark, which we don't have here easily.
+            # For simplicity, we use the mean historical return if pi is not provided.
+            pi = expected_returns.mean_historical_return(prices, frequency=freq)
+        else:
+            pi = expected_returns.mean_historical_return(prices, frequency=freq)
+
+    bl = BlackLittermanModel(
+        cov_matrix,
+        pi=pi,
+        absolute_views=views,
+        omega=None,
+        view_confidences=view_confidences,
+    )
+    ret_bl = bl.bl_returns()
+    ef = EfficientFrontier(ret_bl, cov_matrix)
+    ef.max_sharpe(risk_free_rate=rfr)
+    return ef.clean_weights()
+
+
+def optimized_weights(
+    prices=None, returns=None, rfr=0.0, freq=252, method="equal", **kwargs
+):
     """
     Selects an optimization method to calculate portfolio weights based on user preference.
 
@@ -174,8 +244,12 @@ def optimized_weights(prices=None, returns=None, rfr=0.0, freq=252, method="equa
     """
     if method == "markowitz":
         return markowitz_weights(prices=prices, rfr=rfr, freq=freq)
+    elif method == "min_vol":
+        return markowitz_weights(prices=prices, rfr=rfr, freq=freq, min_vol=True)
     elif method == "hrp":
         return hierarchical_risk_parity(prices=prices, returns=returns, freq=freq)
+    elif method == "black_litterman":
+        return black_litterman_weights(prices=prices, rfr=rfr, freq=freq, **kwargs)
     elif method == "equal":
         return equal_weighted(prices=prices, returns=returns)
     else:

{bbstrader-2.0.7 → bbstrader-2.0.8}/src/bbstrader/trading/execution.py

@@ -21,6 +21,7 @@ try:
     import MetaTrader5 as MT5
 except ImportError:
     import bbstrader.compat  # noqa: F401
+    import MetaTrader5 as MT5
 
 
 __all__ = ["Mt5ExecutionEngine", "RunMt5Engine", "RunMt5Engines"]

{bbstrader-2.0.7 → bbstrader-2.0.8}/tcopier.iss

@@ -1,6 +1,6 @@
 [Setup]
 AppName=TradeCopier
-AppVersion=2.0.4
+AppVersion=2.0.8
 AppPublisher=bbstrading
 DefaultDirName={pf}\TradeCopier
 DefaultGroupName=TradeCopier

{bbstrader-2.0.7 → bbstrader-2.0.8}/tests/api/test_metatrader_client.py

@@ -7,6 +7,7 @@ try:
     import MetaTrader5 as mt5
 except ImportError:
     import bbstrader.compat  # noqa: F401
+    import MetaTrader5 as mt5
 
 from bbstrader.api.handlers import Mt5Handlers
 from bbstrader.api.client import MetaTraderClient  # type: ignore

bbstrader-2.0.8/tests/btengine/test_performance.py

@@ -0,0 +1,58 @@
+import numpy as np
+import pandas as pd
+import pytest
+
+from bbstrader.btengine.performance import (
+    calculate_risk_metrics,
+    create_calmar_ratio,
+    create_drawdowns,
+    create_omega_ratio,
+    create_sharpe_ratio,
+    create_sortino_ratio,
+    create_tail_ratio,
+)
+
+
+@pytest.fixture
+def sample_returns():
+    dates = pd.date_range("2020-01-01", periods=100)
+    returns = pd.Series(np.random.normal(0.001, 0.02, 100), index=dates)
+    return returns
+
+
+@pytest.fixture
+def sample_benchmark():
+    dates = pd.date_range("2020-01-01", periods=100)
+    returns = pd.Series(np.random.normal(0.0005, 0.015, 100), index=dates)
+    return returns
+
+
+def test_create_drawdowns(sample_returns):
+    drawdown, max_dd, max_duration = create_drawdowns(sample_returns)
+    assert isinstance(drawdown, pd.Series)
+    assert isinstance(max_dd, float)
+    assert isinstance(max_duration, (float, int))
+
+
+def test_create_drawdowns_empty():
+    empty_returns = pd.Series([], dtype=float)
+    drawdown, max_dd, max_duration = create_drawdowns(empty_returns)
+    assert drawdown.empty
+    assert max_dd == 0.0
+    assert max_duration == 0.0
+
+
+def test_ratios(sample_returns):
+    assert isinstance(create_sharpe_ratio(sample_returns), (float, np.float64))
+    assert isinstance(create_sortino_ratio(sample_returns), (float, np.float64))
+    assert isinstance(create_omega_ratio(sample_returns), (float, np.float64))
+    assert isinstance(create_calmar_ratio(sample_returns), (float, np.float64))
+    assert isinstance(create_tail_ratio(sample_returns), (float, np.float64))
+
+
+def test_risk_metrics(sample_returns, sample_benchmark):
+    metrics = calculate_risk_metrics(sample_returns, sample_benchmark)
+    assert isinstance(metrics, dict)
+    assert "alpha" in metrics
+    assert "beta" in metrics
+    assert "volatility" in metrics

bbstrader-2.0.8/tests/models/test_optimization.py

@@ -0,0 +1,68 @@
+import pandas as pd
+import numpy as np
+import pytest
+from bbstrader.models.optimization import (
+    markowitz_weights,
+    hierarchical_risk_parity,
+    equal_weighted,
+    optimized_weights,
+    black_litterman_weights,
+)
+
+
+@pytest.fixture
+def sample_prices():
+    dates = pd.date_range("2020-01-01", periods=100)
+    data = {
+        "AAPL": np.linspace(100, 150, 100) + np.random.normal(0, 2, 100),
+        "MSFT": np.linspace(200, 250, 100) + np.random.normal(0, 2, 100),
+        "GOOG": np.linspace(1000, 1100, 100) + np.random.normal(0, 5, 100),
+    }
+    return pd.DataFrame(data, index=dates)
+
+
+def test_markowitz_weights(sample_prices):
+    weights = markowitz_weights(sample_prices)
+    assert isinstance(weights, dict)
+    assert len(weights) == 3
+    assert np.isclose(sum(weights.values()), 1.0)
+
+
+def test_markowitz_min_vol(sample_prices):
+    weights = markowitz_weights(sample_prices, min_vol=True)
+    assert isinstance(weights, dict)
+    assert len(weights) == 3
+    assert np.isclose(sum(weights.values()), 1.0)
+
+
+def test_hrp_weights(sample_prices):
+    weights = hierarchical_risk_parity(prices=sample_prices)
+    assert isinstance(weights, dict)
+    assert len(weights) == 3
+    assert np.isclose(sum(weights.values()), 1.0)
+
+
+def test_equal_weighted(sample_prices):
+    weights = equal_weighted(prices=sample_prices)
+    assert isinstance(weights, dict)
+    assert len(weights) == 3
+    assert all(np.isclose(w, 1 / 3) for w in weights.values())
+
+
+def test_black_litterman_weights(sample_prices):
+    views = {"AAPL": 0.05, "MSFT": 0.02}
+    weights = black_litterman_weights(sample_prices, views=views)
+    assert isinstance(weights, dict)
+    assert len(weights) == 3
+    assert np.isclose(sum(weights.values()), 1.0)
+
+
+def test_optimized_weights_methods(sample_prices):
+    methods = ["markowitz", "min_vol", "hrp", "equal", "black_litterman"]
+    for method in methods:
+        kwargs = {}
+        if method == "black_litterman":
+            kwargs = {"views": {"AAPL": 0.05}}
+        weights = optimized_weights(prices=sample_prices, method=method, **kwargs)
+        assert isinstance(weights, dict)
+        assert np.isclose(sum(weights.values()), 1.0)

bbstrader-2.0.7/VERSION.txt

@@ -1 +0,0 @@
-2.0.7