bbstrader 0.1.91__py3-none-any.whl → 0.1.93__py3-none-any.whl

bbstrader/models/optimization.py

@@ -0,0 +1,177 @@
+import numpy as np
+import pandas as pd
+from pypfopt import risk_models
+from pypfopt import expected_returns
+from pypfopt.efficient_frontier import EfficientFrontier
+from pypfopt.hierarchical_portfolio import HRPOpt
+import warnings
+
+__all__ = [
+    'markowitz_weights', 
+    'hierarchical_risk_parity', 
+    'equal_weighted', 
+    'optimized_weights'
+]
+
+def markowitz_weights(prices=None, rfr=0.0, freq=252):
+    """
+    Calculates optimal portfolio weights using Markowitz's mean-variance optimization (Max Sharpe Ratio) with multiple solvers.
+
+    Parameters:
+    ----------
+    prices : pd.DataFrame, optional
+        Price data for assets, where rows represent time periods and columns represent assets.
+    freq : int, optional
+        Frequency of the data, such as 252 for daily returns in a year (default is 252).
+
+    Returns:
+    -------
+    dict
+        Dictionary containing the optimal asset weights for maximizing the Sharpe ratio, normalized to sum to 1.
+
+    Notes:
+    -----
+    This function attempts to maximize the Sharpe ratio by iterating through various solvers ('SCS', 'ECOS', 'OSQP') 
+    from the PyPortfolioOpt library. If a solver fails, it proceeds to the next one. If none succeed, an error message 
+    is printed for each solver that fails.
+
+    This function is useful for portfolio with a small number of assets, as it may not scale well for large portfolios.
+    
+    Raises:
+    ------
+    Exception
+        If all solvers fail, each will print an exception error message during runtime.
+    """
+    returns = expected_returns.mean_historical_return(prices, frequency=freq)
+    cov = risk_models.sample_cov(prices, frequency=freq)
+
+    # Try different solvers to maximize Sharpe ratio
+    for solver in ['SCS', 'ECOS', 'OSQP']:
+        ef = EfficientFrontier(expected_returns=returns, 
+                               cov_matrix=cov, 
+                               weight_bounds=(0, 1),
+                               solver=solver)
+        try:
+            weights = ef.max_sharpe(risk_free_rate=rfr)
+            return ef.clean_weights()
+        except Exception as e:
+            print(f"Solver {solver} failed with error: {e}")
+
+def hierarchical_risk_parity(prices=None, returns=None, freq=252):
+    """
+    Computes asset weights using Hierarchical Risk Parity (HRP) for risk-averse portfolio allocation.
+
+    Parameters:
+    ----------
+    prices : pd.DataFrame, optional
+        Price data for assets; if provided, daily returns will be calculated.
+    returns : pd.DataFrame, optional
+        Daily returns for assets. One of `prices` or `returns` must be provided.
+    freq : int, optional
+        Number of days to consider in calculating portfolio weights (default is 252).
+
+    Returns:
+    -------
+    dict
+        Optimized asset weights using the HRP method, with asset weights summing to 1.
+
+    Raises:
+    ------
+    ValueError
+        If neither `prices` nor `returns` are provided.
+
+    Notes:
+    -----
+    Hierarchical Risk Parity is particularly useful for portfolios with a large number of assets, 
+    as it mitigates issues of multicollinearity and estimation errors in covariance matrices by 
+    using hierarchical clustering.
+    """
+    warnings.filterwarnings("ignore")
+    if returns is None and prices is None:
+        raise ValueError("Either prices or returns must be provided")
+    if returns is None:
+        returns = prices.pct_change().dropna(how='all')
+    # Remove duplicate columns and index
+    returns = returns.loc[:, ~returns.columns.duplicated()]
+    returns = returns.loc[~returns.index.duplicated(keep='first')]
+    hrp = HRPOpt(returns=returns.iloc[-freq:])
+    return hrp.optimize()
+
+def equal_weighted(prices=None, returns=None, round_digits=5):
+    """
+    Generates an equal-weighted portfolio by assigning an equal proportion to each asset.
+
+    Parameters:
+    ----------
+    prices : pd.DataFrame, optional
+        Price data for assets, where each column represents an asset.
+    returns : pd.DataFrame, optional
+        Return data for assets. One of `prices` or `returns` must be provided.
+    round_digits : int, optional
+        Number of decimal places to round each weight to (default is 5).
+
+    Returns:
+    -------
+    dict
+        Dictionary with equal weights assigned to each asset, summing to 1.
+
+    Raises:
+    ------
+    ValueError
+        If neither `prices` nor `returns` are provided.
+
+    Notes:
+    -----
+    Equal weighting is a simple allocation method that assumes equal importance across all assets, 
+    useful as a baseline model and when no strong views exist on asset return expectations or risk.
+    """
+    if returns is None and prices is None:
+        raise ValueError("Either prices or returns must be provided")
+    if returns is None:
+        n = len(prices.columns)
+        columns = prices.columns
+    else:
+        n = len(returns.columns)
+        columns = returns.columns
+    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'):
+    """
+    Selects an optimization method to calculate portfolio weights based on user preference.
+
+    Parameters:
+    ----------
+    prices : pd.DataFrame, optional
+        Price data for assets, required for certain methods.
+    returns : pd.DataFrame, optional
+        Returns data for assets, an alternative input for certain methods.
+    freq : int, optional
+        Number of days for calculating portfolio weights, such as 252 for a year's worth of daily returns (default is 252).
+    method : str, optional
+        Optimization method to use ('markowitz', 'hrp', or 'equal') (default is 'markowitz').
+
+    Returns:
+    -------
+    dict
+        Dictionary containing optimized asset weights based on the chosen method.
+
+    Raises:
+    ------
+    ValueError
+        If an unknown optimization method is specified.
+
+    Notes:
+    -----
+    This function integrates different optimization methods:
+    - 'markowitz': mean-variance optimization with max Sharpe ratio
+    - 'hrp': Hierarchical Risk Parity, for risk-based clustering of assets
+    - 'equal': Equal weighting across all assets
+    """
+    if method == 'markowitz':
+        return markowitz_weights(prices=prices, rfr=rfr, freq=freq)
+    elif method == 'hrp':
+        return hierarchical_risk_parity(prices=prices, returns=returns, freq=freq)
+    elif method == 'equal':
+        return equal_weighted(prices=prices, returns=returns)
+    else:
+        raise ValueError(f"Unknown method: {method}")

bbstrader/models/portfolios.py

@@ -0,0 +1,205 @@
+import numpy as np
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+from sklearn.decomposition import PCA
+from sklearn.preprocessing import scale
+from bbstrader.models.optimization import (
+    markowitz_weights, 
+    hierarchical_risk_parity, 
+    equal_weighted
+)
+
+__all__ = [
+    'EigenPortfolios'
+]
+
+class EigenPortfolios(object):
+    """
+    The `EigenPortfolios` class applies Principal Component Analysis (PCA) to a covariance matrix of normalized asset returns 
+    to derive portfolios (eigenportfolios) that capture distinct risk factors in the asset returns. Each eigenportfolio 
+    represents a principal component of the return covariance matrix, ordered by the magnitude of its eigenvalue. These 
+    portfolios capture most of the variance in asset returns and are mutually uncorrelated.
+    
+    """
+    def __init__(self):
+        self.returns = None
+        self.n_portfolios = None
+        self._portfolios = None
+        self._fit_called = False
+
+    def get_portfolios(self) -> pd.DataFrame:
+        """
+        Returns the computed eigenportfolios (weights of assets in each portfolio).
+        
+        Returns:
+        -------
+        pd.DataFrame
+            DataFrame containing eigenportfolio weights for each asset.
+        
+        Raises:
+        ------
+        ValueError
+            If `fit()` has not been called before retrieving portfolios.
+        """
+        if not self._fit_called:
+            raise ValueError("fit() must be called first")
+        return self._portfolios
+
+    def fit(self, returns: pd.DataFrame, n_portfolios: int=4) -> pd.DataFrame:
+        """
+        Computes the eigenportfolios based on PCA of the asset returns' covariance matrix.
+        
+        Parameters:
+        ----------
+        returns : pd.DataFrame
+            Historical returns of assets to be used for PCA.
+        n_portfolios : int, optional
+            Number of eigenportfolios to compute (default is 4).
+        
+        Returns:
+        -------
+        pd.DataFrame
+            DataFrame containing normalized weights for each eigenportfolio.
+
+        Notes:
+        -----
+        This method performs winsorization and normalization on returns to reduce the impact of outliers 
+        and achieve zero mean and unit variance. It uses the first `n_portfolios` principal components 
+        as portfolio weights.
+        """
+        # Winsorize and normalize the returns
+        normed_returns = scale(returns
+                            .clip(lower=returns.quantile(q=.025), 
+                                    upper=returns.quantile(q=.975), 
+                                    axis=1)
+                            .apply(lambda x: x.sub(x.mean()).div(x.std())))
+        returns = returns.dropna(thresh=int(normed_returns.shape[0] * .95), axis=1)
+        returns = returns.dropna(thresh=int(normed_returns.shape[1] * .95))
+
+        cov = returns.cov()
+        cov.columns = cov.columns.astype(str)
+        pca = PCA()
+        pca.fit(cov)
+
+        top_portfolios = pd.DataFrame(pca.components_[:n_portfolios], columns=cov.columns)
+        eigen_portfolios = top_portfolios.div(top_portfolios.sum(axis=1), axis=0)
+        eigen_portfolios.index = [f"Portfolio {i}" for i in range(1, n_portfolios + 1)]
+        self._portfolios = eigen_portfolios
+        self.returns = returns
+        self.n_portfolios = n_portfolios
+        self._fit_called = True
+
+    def plot_weights(self):
+        """
+        Plots the weights of each asset in each eigenportfolio as bar charts.
+        
+        Notes:
+        -----
+        Each subplot represents one eigenportfolio, showing the contribution of each asset.
+        """
+        eigen_portfolios = self.get_portfolios()
+        n_cols = 2
+        n_rows = (self.n_portfolios + 1) // n_cols
+        figsize = (n_cols * 10, n_rows * 5)
+        axes = eigen_portfolios.T.plot.bar(subplots=True,
+                                           layout=(n_rows, n_cols),
+                                           figsize=figsize,
+                                           legend=False)
+        for ax in axes.flatten():
+            ax.set_ylabel('Portfolio Weight')
+            ax.set_xlabel('')
+        
+        sns.despine()
+        plt.tight_layout()
+        plt.show()
+
+    def plot_performance(self):
+        """
+        Plots the cumulative returns of each eigenportfolio over time.
+        
+        Notes:
+        -----
+        This method calculates the historical cumulative performance of each eigenportfolio 
+        by weighting asset returns according to eigenportfolio weights.
+        """
+        eigen_portfolios = self.get_portfolios()
+        returns = self.returns.copy()
+        
+        n_cols = 2
+        n_rows = (self.n_portfolios + 1 + n_cols - 1) // n_cols
+        figsize = (n_cols * 10, n_rows * 5)
+        fig, axes = plt.subplots(nrows=n_rows, ncols=n_cols,
+                                 figsize=figsize, sharex=True)
+        axes = axes.flatten()
+        returns.mean(1).add(1).cumprod().sub(1).plot(title='The Market', ax=axes[0])
+        
+        for i in range(self.n_portfolios):
+            rc = returns.mul(eigen_portfolios.iloc[i]).sum(1).add(1).cumprod().sub(1)
+            rc.plot(title=f'Portfolio {i+1}', ax=axes[i + 1], lw=1, rot=0)
+
+        for j in range(self.n_portfolios + 1, len(axes)):
+            fig.delaxes(axes[j])
+
+        for i in range(self.n_portfolios + 1):
+            axes[i].set_xlabel('')
+        
+        sns.despine()
+        fig.tight_layout()
+        plt.show()
+    
+    def optimize(self, portfolio: int = 1, optimizer: str = 'hrp', prices=None, freq=252, plot=True):
+        """
+        Optimizes the chosen eigenportfolio based on a specified optimization method.
+        
+        Parameters:
+        ----------
+        portfolio : int, optional
+            Index of the eigenportfolio to optimize (default is 1).
+        optimizer : str, optional
+            Optimization method: 'markowitz', 'hrp' (Hierarchical Risk Parity), or 'equal' (default is 'hrp').
+        prices : pd.DataFrame, optional
+            Asset prices used for Markowitz optimization (required if optimizer is 'markowitz').
+        freq : int, optional
+            Frequency of returns (e.g., 252 for daily returns).
+        plot : bool, optional
+            Whether to plot the performance of the optimized portfolio (default is True).
+        
+        Returns:
+        -------
+        dict
+            Dictionary of optimized asset weights.
+        
+        Raises:
+        ------
+        ValueError
+            If an unknown optimizer is specified, or if prices are not provided when using Markowitz optimization.
+        
+        Notes:
+        -----
+        The optimization method varies based on risk-return assumptions, with options for traditional Markowitz optimization,
+        Hierarchical Risk Parity, or equal weighting.
+        """
+        portfolio = self.get_portfolios().iloc[portfolio - 1]
+        returns = self.returns.loc[:, portfolio.index]
+        returns =  returns.loc[:, ~returns.columns.duplicated()]
+        returns = returns.loc[~returns.index.duplicated(keep='first')]
+        if optimizer == 'markowitz':
+            if prices is None:
+                raise ValueError("prices must be provided for markowitz optimization")
+            prices = prices.loc[:, returns.columns]
+            weights = markowitz_weights(prices=prices, freq=freq)
+        elif optimizer == 'hrp':
+            weights = hierarchical_risk_parity(returns=returns, freq=freq)
+        elif optimizer == 'equal':
+            weights = equal_weighted(returns=returns)
+        else:
+            raise ValueError(f"Unknown optimizer: {optimizer}")
+        if plot:
+            # plot the optimized potfolio performance
+            returns = returns.filter(weights.keys())
+            rc = returns.mul(weights).sum(1).add(1).cumprod().sub(1)
+            rc.plot(title=f'Optimized {portfolio.name}', lw=1, rot=0)
+            sns.despine()
+            plt.show()
+        return weights

bbstrader/trading/execution.py

@@ -78,10 +78,11 @@ EXIT_SIGNAL_ACTIONS = {
 
 def _mt5_execution(
         symbol_list, trades_instances, strategy_cls, /,
-        mm, trail, stop_trail, trail_after_points, be_plus_points, show_positions_orders,
-        time_frame, iter_time, use_trade_time, period, period_end_action, closing_pnl, trading_days,
+        mm, optimizer, trail, stop_trail, trail_after_points, be_plus_points, show_positions_orders,
+        iter_time, use_trade_time, period, period_end_action, closing_pnl, trading_days,
         comment, **kwargs):
     symbols  = symbol_list.copy()
+    time_frame = kwargs.get('time_frame', '15m')
     STRATEGY = kwargs.get('strategy_name')
     mtrades  = kwargs.get('max_trades')
     notify   = kwargs.get('notify', False)
@@ -89,8 +90,16 @@ def _mt5_execution(
         telegram  = kwargs.get('telegram', False)
         bot_token = kwargs.get('bot_token')
         chat_id   = kwargs.get('chat_id')
+    
+    def update_risk(weights):
+        if weights is not None:
+            for symbol in symbols:
+                if symbol not in weights:
+                    continue
+                trade = trades_instances[symbol]
+                trade.dailydd = round(weights[symbol], 5)
 
-    def _send_notification(self, signal):
+    def _send_notification(signal):
         send_message(message=signal, notify_me=notify, 
                     telegram=telegram, token=bot_token, chat_id=chat_id)
         
@@ -104,8 +113,6 @@ def _mt5_execution(
         if not mm:
             return
         if buys is not None or sells is not None:
-            logger.info(
-                f"Checking for Break even, SYMBOL={symbol}...STRATEGY={STRATEGY}")
             trades_instances[symbol].break_even(
                 mm=mm, trail=trail, stop_trail=stop_trail, 
                 trail_after_points=trail_after_points, be_plus_points=be_plus_points)
@@ -119,10 +126,10 @@ def _mt5_execution(
         check_mt5_connection()
         strategy: MT5Strategy = strategy_cls(symbol_list=symbols, mode='live', **kwargs)
     except Exception as e:
-        logger.error(f"Error initializing strategy, {e}, STRATEGY={STRATEGY}")
+        logger.error(f"Initializing strategy, {e}, STRATEGY={STRATEGY}")
         return
     logger.info(
-        f'Running {STRATEGY} Strategy on {symbols} in {time_frame} Interval ...')
+        f'Running {STRATEGY} Strategy in {time_frame} Interval ...')
     
     while True:
         try:
@@ -132,7 +139,9 @@ def _mt5_execution(
             time.sleep(0.5)
             positions_orders = {}
             for type in POSITIONS_TYPES + ORDERS_TYPES:
+                positions_orders[type] = {}
                 for symbol in symbols:
+                    positions_orders[type][symbol] = None
                     func = getattr(trades_instances[symbol], f"get_current_{type}")
                     positions_orders[type][symbol] = func()
             buys = positions_orders['buys']
@@ -154,12 +163,14 @@ def _mt5_execution(
             }
 
         except Exception as e:
-            logger.error(f"{e}, STRATEGY={STRATEGY}")
+            logger.error(f"Handling Positions and Orders, {e}, STRATEGY={STRATEGY}")
             continue
         time.sleep(0.5)
         try:
             check_mt5_connection()
             signals = strategy.calculate_signals()
+            weights = strategy.apply_risk_management(optimizer)
+            update_risk(weights)
         except Exception as e:
             logger.error(f"Calculating signal, {e}, STRATEGY={STRATEGY}")
             continue
@@ -181,9 +192,10 @@ def _mt5_execution(
                     if signal is not None:
                         signal = 'BMKT' if signal == 'LONG' else signal
                         signal = 'SMKT' if signal == 'SHORT' else signal
-                        info = f"SIGNAL = {signal}, SYMBOL={trade.symbol}, STRATEGY={STRATEGY}"
+                        info = f"SIGNAL = {signal}, SYMBOL={trade.symbol}, STRATEGY={STRATEGY}, TIMEFRAME={time_frame}"
                         msg = f"Sending {signal} Order ... SYMBOL={trade.symbol}, STRATEGY={STRATEGY}"
-                        logger.info(info)
+                        if signal not in EXIT_SIGNAL_ACTIONS:
+                            logger.info(info)
                         if signal in EXIT_SIGNAL_ACTIONS:
                             for exit_signal, actions in EXIT_SIGNAL_ACTIONS.items():
                                 for position_type, order_type in actions.items():
@@ -235,13 +247,15 @@ def _mt5_execution(
                         elif signal in SELLS and short_market[symbol]:
                             logger.info(riskmsg)
                             check(buys[symbol], sells[symbol], symbol)
+                    else:
+                        check(buys[symbol], sells[symbol], symbol)
                 else:
                     logger.info(
                         f"Not trading Time !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
                     check(buys[symbol], sells[symbol], symbol)
 
             except Exception as e:
-                logger.error(f"{e}, SYMBOL={symbol}, STRATEGY={STRATEGY}")
+                logger.error(f"Handling Signals {e}, SYMBOL={symbol}, STRATEGY={STRATEGY}")
                 continue
         time.sleep((60 * iter_time) - 1.0)
         if iter_time == 1:
@@ -253,7 +267,6 @@ def _mt5_execution(
                 f"iter_time must be a multiple of the {time_frame} !!!"
                 f"(e.g; if time_frame is 15m, iter_time must be 1.5, 3, 3, 15 etc)"
             )
-        print()
         try:
             FRIDAY = 'friday'
             check_mt5_connection()
@@ -434,12 +447,12 @@ class MT5ExecutionEngine():
                  strategy_cls:       Strategy,
                  /,
                  mm:                 bool = True,
+                 optimizer:          str = 'equal',
                  trail:              bool = True,
                  stop_trail:         Optional[int] = None,
                  trail_after_points: Optional[int] = None,
                  be_plus_points:     Optional[int] = None,
                  show_positions_orders: bool = False,
-                 time_frame:         str = '15m',
                  iter_time:          int | float = 5,
                  use_trade_time:     bool = True,
                  period:             Literal['day', 'week', 'month'] = 'week',
@@ -455,8 +468,9 @@ class MT5ExecutionEngine():
             trades_instances : Dictionary of Trade instances
             strategy_cls : Strategy class to use for trading
             mm : Enable Money Management. Defaults to False.
+            optimizer : Risk management optimizer. Defaults to 'equal'.
+                See `bbstrader.models.optimization` module for more information.
             show_positions_orders : Print open positions and orders. Defaults to False.
-            time_frame : Time frame to trade. Defaults to '15m'.
             iter_time : Interval to check for signals and `mm`. Defaults to 5.
             use_trade_time : Open trades after the time is completed. Defaults to True.
             period : Period to trade. Defaults to 'week'.
@@ -466,6 +480,7 @@ class MT5ExecutionEngine():
             trading_days : Trading days in a week. Defaults to monday to friday.
             comment: Comment for trades. Defaults to None.
             **kwargs: Additional keyword arguments
+                _ time_frame : Time frame to trade. Defaults to '15m'.
                 - strategy_name (Optional[str]): Strategy name. Defaults to None.
                 - max_trades (Dict[str, int]): Maximum trades per symbol. Defaults to None.
                 - notify (bool): Enable notifications. Defaults to False.
@@ -495,12 +510,12 @@ class MT5ExecutionEngine():
         self.trades_instances = trades_instances
         self.strategy_cls = strategy_cls
         self.mm = mm
+        self.optimizer = optimizer
         self.trail = trail
         self.stop_trail = stop_trail
         self.trail_after_points = trail_after_points
         self.be_plus_points = be_plus_points
         self.show_positions_orders = show_positions_orders
-        self.time_frame = time_frame
         self.iter_time = iter_time
         self.use_trade_time = use_trade_time
         self.period = period
@@ -517,12 +532,12 @@ class MT5ExecutionEngine():
             self.trades_instances,
             self.strategy_cls,
             mm=self.mm,
+            optimizer=self.optimizer,
             trail=self.trail,
             stop_trail=self.stop_trail,
             trail_after_points=self.trail_after_points,
             be_plus_points=self.be_plus_points,
             show_positions_orders=self.show_positions_orders,
-            time_frame=self.time_frame,
             iter_time=self.iter_time,
             use_trade_time=self.use_trade_time,
             period=self.period,

{bbstrader-0.1.91.dist-info → bbstrader-0.1.93.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bbstrader
-Version: 0.1.91
+Version: 0.1.93
 Summary: Simplified Investment & Trading Toolkit
 Home-page: https://github.com/bbalouki/bbstrader
 Download-URL: https://pypi.org/project/bbstrader/
@@ -46,6 +46,7 @@ Requires-Dist: tqdm
 Requires-Dist: scikit-learn
 Requires-Dist: notify-py
 Requires-Dist: python-telegram-bot
+Requires-Dist: pyportfolioopt
 Provides-Extra: mt5
 Requires-Dist: MetaTrader5 ; extra == 'mt5'
 

bbstrader-0.1.93.dist-info/RECORD

@@ -0,0 +1,32 @@
+bbstrader/__ini__.py,sha256=rCTy-3g2RlDAgIZ7cSET9-I74MwuCXpp-xGVTFS8NNc,482
+bbstrader/config.py,sha256=_AD_Cd-w5zyabm1CBPNGhzcZuSjThB7jyzTcjbrIlUQ,3618
+bbstrader/tseries.py,sha256=qJKLxHnPOjB7dXon-ITK7vU1fAuvl8evzET6lSSnijQ,53572
+bbstrader/btengine/__init__.py,sha256=OaXZTjgDwqWrjPq-CNE4kJkmriKXt9t5pIghW1MDTeo,2911
+bbstrader/btengine/backtest.py,sha256=A3S84jpGTE_zhguOEGoGu6H_4ws4Iq5sf0n7TZaUYfQ,14615
+bbstrader/btengine/data.py,sha256=A6jUqDnjl-w1OSzbLLPfS1WfJ8Se25AqigJs9pbe0wc,17966
+bbstrader/btengine/event.py,sha256=zF_ST4tcjV5uJJVV1IbRXQgCLbca2R2fmE7A2MaIno4,8748
+bbstrader/btengine/execution.py,sha256=Fs6Hk64DxEOEVzAjsQ3CIVvYifWLLgkDjOixSh_Ghsc,10282
+bbstrader/btengine/performance.py,sha256=WTYzB50lUD5aShPIEebbQPlaC2NVW6VfxdgGHjcIIAw,10707
+bbstrader/btengine/portfolio.py,sha256=wCRmGxaZvihUPlXIlZp9cQo9fqPP-Tk5oALjknMfnos,16055
+bbstrader/btengine/strategy.py,sha256=6IN1KQ-a-IQgbCEOflKTtGh-ouztwsVjik6TuMg6CY0,30210
+bbstrader/metatrader/__init__.py,sha256=OLVOB_EieEb1P72I8V4Vem8kQWJ__D_L3c_wfwqY-9k,211
+bbstrader/metatrader/account.py,sha256=3KeGLZ397kctf3EW_y8n9ENswAMU0tBQJuX_L0VXMrI,53909
+bbstrader/metatrader/rates.py,sha256=1dJHbVqoT41m3EhF0wRe7dSGe5Kf3o5Maskkw-i5qsQ,20810
+bbstrader/metatrader/risk.py,sha256=8NnH1kRvWd_JLieCpVty6hHKz2awrIQV2c8oykxELh0,26596
+bbstrader/metatrader/trade.py,sha256=uigDah9n_rVJiwSslTAArLP94sde1dxYyGyRVIPPgb4,70210
+bbstrader/metatrader/utils.py,sha256=BTaZun4DKWpCxBBzY0SLQqqz7n_7F_R1F59APfyaa3E,17666
+bbstrader/models/__init__.py,sha256=mpxtXYEcE8hwNDbzJf8MRqnBIa2T1voraEk0U0ri53c,437
+bbstrader/models/factors.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bbstrader/models/ml.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bbstrader/models/optimization.py,sha256=JlMsda9L-ADSgw4YPE4o3CsL1Yyxfeahf9kUb-EZqqM,6699
+bbstrader/models/portfolios.py,sha256=dFTZ3maRVY_O3UOIoRlLCbAow3SiLTQYt1q5DNaRUxE,8223
+bbstrader/models/risk.py,sha256=Pm_WoGI-vtPW75fwo_7ptF2Br-xQYBwrAAOIgqDQmy8,15120
+bbstrader/trading/__init__.py,sha256=3CCzV5rQbH8NthjDJhD0_2FABvpiCmkeC9cVeoW7bi4,438
+bbstrader/trading/execution.py,sha256=p_SKUziBBDuGiOmuxBsgBvxWu5nDVGZmtQBKw8OoZgE,25967
+bbstrader/trading/scripts.py,sha256=rQmnG_4F_MuUEc96RXpAQT4kXrC-FkscsgHKgDAR_-Y,1902
+bbstrader/trading/strategies.py,sha256=ztKNL4Nmlb-4N8_cq0OJyn3E2cRcdKdKu3FeTbZrHsU,36402
+bbstrader-0.1.93.dist-info/LICENSE,sha256=1EudjwwP2oTJy8Vh0e-Kzv8VZZU95y-t6c3DYhR51uc,1115
+bbstrader-0.1.93.dist-info/METADATA,sha256=XByGtsQ885U8oZpZOR9DPhQjdfi5eHbScJyGlcbbjxM,9932
+bbstrader-0.1.93.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+bbstrader-0.1.93.dist-info/top_level.txt,sha256=Wwj322jZmxGZ6gD_TdaPiPLjED5ReObm5omerwlmZIg,10
+bbstrader-0.1.93.dist-info/RECORD,,

{bbstrader-0.1.91.dist-info → bbstrader-0.1.93.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.5.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

bbstrader-0.1.91.dist-info/RECORD

@@ -1,31 +0,0 @@
-bbstrader/__ini__.py,sha256=rCTy-3g2RlDAgIZ7cSET9-I74MwuCXpp-xGVTFS8NNc,482
-bbstrader/config.py,sha256=_AD_Cd-w5zyabm1CBPNGhzcZuSjThB7jyzTcjbrIlUQ,3618
-bbstrader/tseries.py,sha256=qJKLxHnPOjB7dXon-ITK7vU1fAuvl8evzET6lSSnijQ,53572
-bbstrader/btengine/__init__.py,sha256=OaXZTjgDwqWrjPq-CNE4kJkmriKXt9t5pIghW1MDTeo,2911
-bbstrader/btengine/backtest.py,sha256=HDuCNUETLUBZ0R8AVLeT5gZVVk8UQ6oeReUtDvUFhIk,13681
-bbstrader/btengine/data.py,sha256=zeF3O7_vPT3NvAxlAcUS9OoxF09XhypDhGiVRml3U1A,17622
-bbstrader/btengine/event.py,sha256=DQTmUQ4l4yZgL47hW1dGv__CecNF-rDqsyFst5kCQvA,8453
-bbstrader/btengine/execution.py,sha256=gijnRvknNi921TjtF9wSyBG_nI0e2cda2NKIm3LJh1k,10222
-bbstrader/btengine/performance.py,sha256=bKwj1_CSygvggLKTXPASp2eWhDdwyCf06ayUaXwdh4E,10655
-bbstrader/btengine/portfolio.py,sha256=uf1fx0RuTTQNNxiYmCYW_sh6sBWbtNq4uIRusKA5MdY,15399
-bbstrader/btengine/strategy.py,sha256=ktTzlJzSTo9zhZsILwj2vtPHjAkI-aSnKA8PcT3nF6Y,23206
-bbstrader/metatrader/__init__.py,sha256=OLVOB_EieEb1P72I8V4Vem8kQWJ__D_L3c_wfwqY-9k,211
-bbstrader/metatrader/account.py,sha256=hVH83vnAdfMOzUsF9PiWelqxa7HaLSTpCVlUEePnSZg,53912
-bbstrader/metatrader/rates.py,sha256=xWTsM8PMPGdgwoPXcIRvHpJ1FKRIXHJcn4qrgmA7XRg,18737
-bbstrader/metatrader/risk.py,sha256=8FcLY8pgV8_rxAcjx179sdqaMu66wl-fDFPZvdihfUw,25953
-bbstrader/metatrader/trade.py,sha256=68hYIA01OPApRgGNdS1YFgM83ZemkCmv6mTXOCS_kWc,70052
-bbstrader/metatrader/utils.py,sha256=BTaZun4DKWpCxBBzY0SLQqqz7n_7F_R1F59APfyaa3E,17666
-bbstrader/models/__init__.py,sha256=6tAj9V9vgwesgPVMKznwRB3k8-Ec8Q73Di5p2UO0qlA,274
-bbstrader/models/factors.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bbstrader/models/ml.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bbstrader/models/optimization.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bbstrader/models/risk.py,sha256=Pm_WoGI-vtPW75fwo_7ptF2Br-xQYBwrAAOIgqDQmy8,15120
-bbstrader/trading/__init__.py,sha256=3CCzV5rQbH8NthjDJhD0_2FABvpiCmkeC9cVeoW7bi4,438
-bbstrader/trading/execution.py,sha256=5mGanLIB1nPfbXA9r_uKGDCkcV-ilVgZmssF7Oh4SeI,25186
-bbstrader/trading/scripts.py,sha256=rQmnG_4F_MuUEc96RXpAQT4kXrC-FkscsgHKgDAR_-Y,1902
-bbstrader/trading/strategies.py,sha256=ztKNL4Nmlb-4N8_cq0OJyn3E2cRcdKdKu3FeTbZrHsU,36402
-bbstrader-0.1.91.dist-info/LICENSE,sha256=1EudjwwP2oTJy8Vh0e-Kzv8VZZU95y-t6c3DYhR51uc,1115
-bbstrader-0.1.91.dist-info/METADATA,sha256=ZwHR-DYmIhULp_5dh48oQ_lGR0VYQnkGG8GcaQe1KP4,9901
-bbstrader-0.1.91.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-bbstrader-0.1.91.dist-info/top_level.txt,sha256=Wwj322jZmxGZ6gD_TdaPiPLjED5ReObm5omerwlmZIg,10
-bbstrader-0.1.91.dist-info/RECORD,,