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

bbstrader/tseries.py

@@ -6,32 +6,35 @@ tasks such as cointegration testing, volatility modeling,
 and filter-based estimation to assist in trading strategy development, 
 market analysis, and financial data exploration.
 """
-import numpy as np
-import pandas as pd
 import pprint
 import warnings
+import numpy as np
+import pandas as pd
+from   tqdm import tqdm
 import yfinance as yf
-from arch import arch_model
-from statsmodels.tsa.arima.model import ARIMA
 import pmdarima as pm
-import matplotlib.pyplot as plt
+import seaborn as sns
 import statsmodels.api as sm
+import matplotlib.pyplot as plt
 import statsmodels.tsa.stattools as ts
-from numpy import cumsum, log, polyfit, sqrt, std, subtract
-from numpy.random import randn
 from hurst import compute_Hc
+from arch import arch_model
 from scipy.optimize import minimize
 from filterpy.kalman import KalmanFilter
+from pykalman import KalmanFilter as PyKalmanFilter
 from statsmodels.tsa.vector_ar.vecm import coint_johansen
 from statsmodels.graphics.tsaplots import plot_acf
+from statsmodels.tsa.stattools import adfuller, coint
+from statsmodels.tsa.arima.model import ARIMA
+from statsmodels.tsa.vector_ar.var_model import VAR
+from sklearn.model_selection import GridSearchCV
+from sklearn.tree import  DecisionTreeClassifier
+from sklearn.linear_model import LogisticRegressionCV
+from statsmodels.stats.diagnostic import acorr_ljungbox
 from itertools import combinations
 from typing import Union, List, Tuple
-from statsmodels.stats.diagnostic import acorr_ljungbox
-from arch.utility.exceptions import ConvergenceWarning as ArchWarning
-from statsmodels.tools.sm_exceptions import ConvergenceWarning as StatsWarning
 warnings.filterwarnings("ignore")
-warnings.filterwarnings("ignore", category=StatsWarning, module='statsmodels')
-warnings.filterwarnings("ignore", category=ArchWarning, module='arch')
+
 
 
 __all__ = [
@@ -117,18 +120,23 @@ def fit_best_arima(window_data: Union[pd.Series, np.ndarray]):
         stepwise=True
     )
     final_order = model.order
-    try:
-        best_arima_model = ARIMA(
-            window_data + 1e-5, order=final_order, missing='drop').fit()
-        return best_arima_model
-    except np.linalg.LinAlgError:
-        # Catch specific linear algebra errors
-        print("LinAlgError occurred, skipping this data point.")
-        return None
-    except Exception as e:
-        # Catch any other unexpected errors and log them
-        print(f"An error occurred: {e}")
-        return None
+    from arch.utility.exceptions import ConvergenceWarning as ArchWarning
+    from statsmodels.tools.sm_exceptions import ConvergenceWarning as StatsWarning
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", category=StatsWarning, module='statsmodels')
+        warnings.filterwarnings("ignore", category=ArchWarning, module='arch')
+        try:
+            best_arima_model = ARIMA(
+                window_data + 1e-5, order=final_order, missing='drop').fit()
+            return best_arima_model
+        except np.linalg.LinAlgError:
+            # Catch specific linear algebra errors
+            print("LinAlgError occurred, skipping this data point.")
+            return None
+        except Exception as e:
+            # Catch any other unexpected errors and log them
+            print(f"An error occurred: {e}")
+            return None
 
 
 def fit_garch(window_data:  Union[pd.Series, np.ndarray]):
@@ -684,10 +692,10 @@ def _hurst(ts):
     lags = range(2, 100)
 
     # Calculate the array of the variances of the lagged differences
-    tau = [sqrt(std(subtract(ts[lag:], ts[:-lag]))) for lag in lags]
+    tau = [np.sqrt(np.std(np.subtract(ts[lag:], ts[:-lag]))) for lag in lags]
 
     # Use a linear fit to estimate the Hurst Exponent
-    poly = polyfit(log(lags), log(tau), 1)
+    poly = np.polyfit(np.log(lags), np.log(tau), 1)
 
     # Return the Hurst exponent from the polyfit output
     return poly[0] * 2.0
@@ -721,9 +729,9 @@ def run_hurst_test(symbol: str, start: str, end: str):
     data = yf.download(symbol, start=start, end=end)
 
     # Create a Geometric Brownian Motion, Mean-Reverting, and Trending Series
-    gbm = log(cumsum(randn(100000))+1000)
-    mr = log(randn(100000)+1000)
-    tr = log(cumsum(randn(100000)+1)+1000)
+    gbm = np.log(np.cumsum(np.random.randn(100000))+1000)
+    mr = np.log(np.random.randn(100000)+1000)
+    tr = np.log(np.cumsum(np.random.randn(100000)+1)+1000)
 
     # Output the Hurst Exponent for each of the series
     print(f"\nHurst(GBM):  {_hurst(gbm)}")
@@ -898,7 +906,7 @@ class KalmanFilterModel():
     You can learn more here https://en.wikipedia.org/wiki/Kalman_filter
     """
 
-    def __init__(self, tickers: list | tuple, **kwargs):
+    def __init__(self, tickers: List | Tuple, **kwargs):
         """
         Initializes the Kalman Filter strategy.
 
@@ -907,7 +915,7 @@ class KalmanFilterModel():
             A list or tuple of ticker symbols representing financial instruments.
 
             kwargs : Keyword arguments for additional parameters,
-             specifically `delta` and `vt`
+            specifically `delta` and `vt`
         """
         self.tickers = tickers
         assert self.tickers is not None
@@ -936,7 +944,8 @@ class KalmanFilterModel():
 
         return kf
 
-    def calc_slope_intercep(self, prices: np.ndarray):
+    Array = np.ndarray
+    def calc_slope_intercep(self, prices: Array) -> Tuple:
         """
         Calculates and returns the slope and intercept 
         of the relationship between the provided prices using the Kalman Filter. 
@@ -957,8 +966,8 @@ class KalmanFilterModel():
         intercept = kf.x.copy().flatten()[1]
 
         return slope, intercept
-
-    def calculate_etqt(self, prices: np.ndarray):
+    
+    def calculate_etqt(self, prices: Array) -> Tuple:
         """
         Calculates the forecast error and standard deviation of the predictions
         using the Kalman Filter.
@@ -1144,21 +1153,19 @@ class OrnsteinUhlenbeck():
         ) / sigma**2 + 0.5 * n * np.log(2 * np.pi * sigma**2)
         return neg_ll
 
-    def simulate_process(self, rts=None, n=100, p=None):
+    def simulate_process(self, returns=None, n=100, p=None):
         """
         Simulates the OU process multiple times .
 
         Args:
-            rts (np.ndarray): Historical returns.
+            returns (np.ndarray): Historical returns.
             n (int): Number of simulations to perform.
             p (int): Number of time steps.
 
         Returns:
             np.ndarray: 2D array representing simulated processes.
         """
-        if rts is not None:
-            returns = rts
-        else:
+        if returns is  None:
             returns = self.returns
         if p is not None:
             T = p
@@ -1180,3 +1187,231 @@ class OrnsteinUhlenbeck():
                 self.sigma_hat * dW_matrix[:, t]
             )
         return simulations_matrix
+
+
+def remove_correlated_assets(df: pd.DataFrame, cutoff=.99):
+    corr = df.corr().stack()
+    corr = corr[corr < 1]
+    to_check = corr[corr.abs() > cutoff].index
+    keep, drop = set(), set()
+    for s1, s2 in to_check:
+        if s1 not in keep:
+            if s2 not in keep:
+                keep.add(s1)
+                drop.add(s2)
+            else:
+                drop.add(s1)
+        else:
+            keep.discard(s2)
+            drop.add(s2)
+    return df.drop(drop, axis=1)
+
+
+def check_stationarity(df: pd.DataFrame):
+    results = []
+    for ticker, prices in df.items():
+        results.append([ticker, adfuller(prices, regression='ct')[1]])
+    return pd.DataFrame(results, columns=['ticker', 'adf']).sort_values('adf')
+
+
+def remove_stationary_assets(df: pd.DataFrame, pval=.05):
+    test_result = check_stationarity(df)
+    stationary = test_result.loc[test_result.adf <= pval, 'ticker'].tolist()
+    return df.drop(stationary, axis=1).sort_index()
+
+
+def select_assets(df: pd.DataFrame, n=100, start=None, end=None):
+    idx = pd.IndexSlice
+    start = start or df.index.get_level_values('date').min()
+    end = end or df.index.get_level_values('date').max()
+    df = (df
+        .loc[lambda df: ~df.index.duplicated()]
+        .sort_index()
+        .loc[idx[:, f'{start}':f'{end}'], :]
+        .assign(dv=lambda df: df.close.mul(df.volume)))
+
+    # select n assets with the highest average trading volume
+    # we are taking a shortcut to simplify; should select
+    # based on historical only, e.g. yearly rolling avg
+    most_traded = (df.groupby(level='ticker')
+                .dv.mean()
+                .nlargest(n=n).index)
+
+    df = (df.loc[idx[most_traded, :], 'close']
+        .unstack('ticker')
+        .ffill(limit=5)  # fill up to five values
+        .dropna(axis=1))  # remove assets with any missing values
+
+    df = remove_correlated_assets(df)
+    return remove_stationary_assets(df).sort_index()
+
+def compute_pair_metrics(security: pd.Series, candidates: pd.DataFrame):
+    security = security.div(security.iloc[0])
+    ticker = security.name
+    candidates = candidates.div(candidates.iloc[0])
+    spreads = candidates.sub(security, axis=0)
+    n, m = spreads.shape
+    X = np.ones(shape=(n, 2))
+    X[:, 1] = np.arange(1, n + 1)
+    
+    # compute drift
+    drift = ((np.linalg.inv(X.T @ X) @ X.T @ spreads).iloc[1]
+             .to_frame('drift'))
+    
+    # compute volatility
+    vol = spreads.std().to_frame('vol')
+    
+    # return correlation
+    corr_ret = (candidates.pct_change()
+                .corrwith(security.pct_change())
+                .to_frame('corr_ret'))
+    
+    # normalized price series correlation
+    corr = candidates.corrwith(security).to_frame('corr')
+    metrics = drift.join(vol).join(corr).join(corr_ret).assign(n=n)
+    
+    tests = []
+    # run cointegration tests
+    for candidate, prices in tqdm(candidates.items()):
+        df = pd.DataFrame({'s1': security, 's2': prices})
+        var = VAR(df.values)
+        lags = var.select_order() # select VAR order
+        k_ar_diff = lags.selected_orders['aic']
+        # Johansen Test with constant Term and estd. lag order
+        cj0 = coint_johansen(df, det_order=0, k_ar_diff=k_ar_diff)
+        # Engle-Granger Tests
+        t1, p1 = coint(security, prices, trend='c')[:2]
+        t2, p2 = coint(prices, security, trend='c')[:2]
+        tests.append([ticker, candidate, t1, p1, t2, p2, 
+                      k_ar_diff, *cj0.lr1])
+    columns = ['s1', 's2', 't1', 'p1', 't2', 'p2', 'k_ar_diff', 'trace0', 'trace1']
+    tests = pd.DataFrame(tests, columns=columns).set_index('s2')
+    return metrics.join(tests)
+
+CRITICAL_VALUES = {
+    0: {.9: 13.4294, .95: 15.4943, .99: 19.9349},
+    1: {.9: 2.7055, .95: 3.8415, .99: 6.6349}
+}
+
+def find_cointegrated_pairs(securities: pd.DataFrame, candidates: pd.DataFrame, 
+                            n=None, start=None, stop=None):
+    trace0_cv = CRITICAL_VALUES[0][.95] # critical value for 0 cointegration relationships
+    trace1_cv = CRITICAL_VALUES[1][.95] # critical value for 1 cointegration relationship
+    spreads = []
+    if start is not None and stop is not None:
+        securities = securities.loc[str(start): str(stop), :]
+        candidates = candidates.loc[str(start): str(stop), :]
+    for i, (ticker, prices) in enumerate(securities.items(), 1):
+        df = compute_pair_metrics(prices, candidates)
+        spreads.append(df.set_index('s1', append=True))
+    spreads = pd.concat(spreads)
+    spreads.index.names = ['s2', 's1']
+    spreads = spreads.swaplevel()
+    spreads['t'] = spreads[['t1', 't2']].min(axis=1)
+    spreads['p'] = spreads[['p1', 'p2']].min(axis=1)
+    spreads['joh_sig'] = ((spreads.trace0 > trace0_cv) &
+                        (spreads.trace1 > trace1_cv)).astype(int)
+    spreads['eg_sig'] = (spreads.p < .05).astype(int)
+    spreads['s1_dep'] = spreads.p1 < spreads.p2
+    spreads['coint'] = (spreads.joh_sig & spreads.eg_sig).astype(int)
+    # select top n pairs
+    if n is not None:
+        top_pairs = (spreads.query('coint == 1')
+                    .sort_values('t', ascending=False)
+                    .head(n))
+    else:
+        top_pairs = spreads.query('coint == 1')
+    return top_pairs
+
+def analyze_cointegrated_pairs(spreads: pd.DataFrame, plot_coint=False, cosstab=False, 
+                               heuristics=False, log_reg=False, decis_tree=False):
+    if plot_coint:
+        trace0_cv = CRITICAL_VALUES[0][.95]
+        spreads = spreads.reset_index()
+        sns.scatterplot(x=np.log1p(spreads.t.abs()), 
+                        y=np.log1p(spreads.trace1), 
+                        hue='coint', data=spreads[spreads.trace0>trace0_cv]);
+        fig, axes = plt.subplots(ncols=4, figsize=(20, 5))
+        for i, heuristic in enumerate(['drift', 'vol', 'corr', 'corr_ret']):
+            sns.boxplot(x='coint', y=heuristic, data=spreads, ax=axes[i])
+        fig.tight_layout();
+    if heuristics:
+        spreads = spreads.reset_index()
+        h = spreads.groupby(spreads.coint)[
+            ['drift', 'vol', 'corr']].describe().stack(level=0).swaplevel().sort_index()
+        print(h)
+    if log_reg:
+        y = spreads.coint
+        X = spreads[['drift', 'vol', 'corr', 'corr_ret']]
+        log_reg = LogisticRegressionCV(Cs=np.logspace(-10, 10, 21), 
+                               class_weight='balanced',
+                               scoring='roc_auc')
+        log_reg.fit(X=X, y=y)
+        Cs = log_reg.Cs_
+        scores = pd.DataFrame(log_reg.scores_[True], columns=Cs).mean()
+        scores.plot(logx=True);
+        res = f'C:{np.log10(scores.idxmax()):.2f}, AUC: {scores.max():.2%}'
+        print(res)
+        print(log_reg.coef_)
+    if decis_tree:
+        model = DecisionTreeClassifier(class_weight='balanced')
+        decision_tree = GridSearchCV(model,
+                             param_grid={'max_depth': list(range(1, 10))},
+                             cv=5,
+                             scoring='roc_auc')
+        y = spreads.coint
+        X = spreads[['drift', 'vol', 'corr', 'corr_ret']]
+        decision_tree.fit(X, y)
+        res = f'{decision_tree.best_score_:.2%}, Depth: {decision_tree.best_params_["max_depth"]}'
+        print(res)
+    if cosstab:
+        pd.set_option('display.float_format', lambda x: f'{x:.2%}')
+        print(pd.crosstab(spreads.eg_sig, spreads.joh_sig))
+        print(pd.crosstab(spreads.eg_sig, spreads.joh_sig, normalize=True))
+
+
+def select_candidate_pairs(pairs: pd.DataFrame):
+    candidates = pairs.query('coint == 1').copy()
+    candidates['y'] = candidates.apply(lambda x: x.s1 if x.s1_dep else x.s2, axis=1)
+    candidates['x'] = candidates.apply(lambda x: x.s2 if x.s1_dep else x.s1, axis=1)
+    candidates.drop(['s1_dep', 's1', 's2'], axis=1)
+    return candidates[['x', 'y']].to_dict(orient='records')
+
+
+def KFSmoother(self, prices: pd.Series | np.ndarray) -> pd.Series | np.ndarray:
+    """Estimate rolling mean using Kalman Smoothing."""
+    kf = PyKalmanFilter(
+        transition_matrices=np.eye(1),
+        observation_matrices=np.eye(1),
+        initial_state_mean=0,
+        initial_state_covariance=1,
+        observation_covariance=1,
+        transition_covariance=0.05
+    )
+    if isinstance(prices, pd.Series):
+        state_means, _ = kf.filter(prices.values)
+        return pd.Series(state_means.flatten(), index=prices.index)
+    elif isinstance(prices, np.ndarray):
+        state_means, _ = kf.filter(prices)
+        return state_means.flatten()
+
+
+def KFHedgeRatio(self, x: pd.Series, y: pd.Series) -> np.ndarray:
+    """Estimate Hedge Ratio using Kalman Filter."""
+    delta = 1e-3
+    trans_cov = delta / (1 - delta) * np.eye(2)
+    obs_mat = np.expand_dims(np.vstack([[x], [np.ones(len(x))]]).T, axis=1)
+
+    kf = PyKalmanFilter(
+        n_dim_obs=1, n_dim_state=2,
+        initial_state_mean=[0, 0],
+        initial_state_covariance=np.ones((2, 2)),
+        transition_matrices=np.eye(2),
+        observation_matrices=obs_mat,
+        observation_covariance=2,
+        transition_covariance=trans_cov
+    )
+    state_means, _ = kf.filter(y.values)
+    # Indexing with [:, 0] in state_means[:, 0] extracts only the first state variable of 
+    # each Kalman Filter estimate, which is the estimated hedge ratio.
+    return -state_means[:, 0]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bbstrader
-Version: 0.1.9
+Version: 0.1.91
 Summary: Simplified Investment & Trading Toolkit
 Home-page: https://github.com/bbalouki/bbstrader
 Download-URL: https://pypi.org/project/bbstrader/
@@ -34,12 +34,20 @@ Requires-Dist: seaborn
 Requires-Dist: statsmodels
 Requires-Dist: matplotlib
 Requires-Dist: filterpy
+Requires-Dist: pykalman
 Requires-Dist: pytest
 Requires-Dist: CurrencyConverter
 Requires-Dist: tabulate
+Requires-Dist: python-dotenv
 Requires-Dist: ipython
-Requires-Dist: quantstats
-Requires-Dist: Metatrader5
+Requires-Dist: QuantStats
+Requires-Dist: exchange-calendars
+Requires-Dist: tqdm
+Requires-Dist: scikit-learn
+Requires-Dist: notify-py
+Requires-Dist: python-telegram-bot
+Provides-Extra: mt5
+Requires-Dist: MetaTrader5 ; extra == 'mt5'
 
 # Simplified Investment & Trading Toolkit
 ![bbstrader](https://github.com/bbalouki/bbstrader/blob/main/assets/bbstrader_logo.png?raw=true)

bbstrader-0.1.91.dist-info/RECORD

@@ -0,0 +1,31 @@
+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,,

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

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

bbstrader-0.1.9.dist-info/RECORD

@@ -1,26 +0,0 @@
-bbstrader/__ini__.py,sha256=lKhqaZN2fuGU2DP3oufJ_XcFlznnyNTlhklWcOaTPMY,444
-bbstrader/tseries.py,sha256=i6Vl5QeySMj51n4EchvAaGnHl1xQLdvO7Eka3QkP_Mg,43647
-bbstrader/btengine/__init__.py,sha256=gNANXdJ_b4JQaHgqXTbRSZzJOdZRQop5258GQYIAY8s,2949
-bbstrader/btengine/backtest.py,sha256=bUnuxHByddDkY2VzCTSBBOIbdRzsy9VXROFYL3VNwzE,12450
-bbstrader/btengine/data.py,sha256=B2cqkZZGIhedqMHeZBNB6RHGyeP-TFGOSlMoZq4uFUw,14007
-bbstrader/btengine/event.py,sha256=dY2DFwRPDCEdsX7GnLiwpth73tOpnbjgqIqbkNMZu1U,8286
-bbstrader/btengine/execution.py,sha256=noat6ZxhbBYZQ0GLFYw78enp0vZCbeoGyOok4aSjWCA,5077
-bbstrader/btengine/performance.py,sha256=STb5xJQiTa25xZdYYmjpKW46iWWcB_-6wB6PCPbhREI,10745
-bbstrader/btengine/portfolio.py,sha256=LFsl38GbdYTJwd08ep1n4_1FPsRodQz1DHDPVSj-rBU,14882
-bbstrader/btengine/strategy.py,sha256=uLQdsEzI8-86Cj7HWkL8blVFxT0sNxEcLVnkBil6ZLk,1550
-bbstrader/metatrader/__init__.py,sha256=y4JLz05esm3PKerHMgtd3dmRpa7yUvWVuj_xOnlhXSA,261
-bbstrader/metatrader/account.py,sha256=5f6emtVEvXmxUnlmqFpC4hhL8sxOzOrdp7_pwJhXPhw,44716
-bbstrader/metatrader/rates.py,sha256=FyG4WWq1NaCdHNxEW_8u3eOt0Wms7E_U4FIOIcUDWco,9605
-bbstrader/metatrader/risk.py,sha256=Nz3RqkVFNA5FeXIqINjmGUaj88YaYGw23XsVOvaHjB8,25831
-bbstrader/metatrader/trade.py,sha256=M5ho8x_NRVCEWO_dmDCiJrhhbcfpnia6tOmQRfV7p4U,62967
-bbstrader/metatrader/utils.py,sha256=xc5VYQ-eejpHIPJIhLi8vxAF5zjix5NSXywXu2Eb7LI,19186
-bbstrader/models/__init__.py,sha256=6tAj9V9vgwesgPVMKznwRB3k8-Ec8Q73Di5p2UO0qlA,274
-bbstrader/models/risk.py,sha256=Pm_WoGI-vtPW75fwo_7ptF2Br-xQYBwrAAOIgqDQmy8,15120
-bbstrader/trading/__init__.py,sha256=3_PeIcuQ7znoCPdq8FqRmbCc0czNiernpIRkBXJZvg0,452
-bbstrader/trading/execution.py,sha256=Y3iKLbgCNVLw2XTDUM8Mv6hlcO8H83VyMKlZgjAKX2c,20744
-bbstrader/trading/strategies.py,sha256=uYVeFeqVHHYrkgk4Eiziivj0iIO0RQKXCAoOSQ4XVRE,36972
-bbstrader-0.1.9.dist-info/LICENSE,sha256=1EudjwwP2oTJy8Vh0e-Kzv8VZZU95y-t6c3DYhR51uc,1115
-bbstrader-0.1.9.dist-info/METADATA,sha256=aJILSlgr7yOdyozYyZPseOUUy7WkJcgHUv-TnudXSvY,9660
-bbstrader-0.1.9.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-bbstrader-0.1.9.dist-info/top_level.txt,sha256=Wwj322jZmxGZ6gD_TdaPiPLjED5ReObm5omerwlmZIg,10
-bbstrader-0.1.9.dist-info/RECORD,,