sdevpy 1.0.6__tar.gz → 1.0.8__tar.gz

{sdevpy-1.0.6 → sdevpy-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdevpy
-Version: 1.0.6
+Version: 1.0.8
 Summary: Python package for Finance
 Author-email: Sebastien Gurrieri <sebgur@gmail.com>
 Project-URL: Git page, https://github.com/sebgur/SDev.Python
@@ -11,6 +11,13 @@ Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 Requires-Dist: pandas
 Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: holidays
+Requires-Dist: pandas_market_calendars
+Requires-Dist: openpyxl
+Requires-Dist: colorlog
+Requires-Dist: scikit-learn
 
 # SDev.Python
 

sdevpy-1.0.8/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sdevpy"
+version = "1.0.8"
+license-files = []
+authors = [{ name="Sebastien Gurrieri", email="sebgur@gmail.com" }]
+description = "Python package for Finance"
+readme = "README.md"
+requires-python = ">=3.6"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = ["pandas", "numpy", "scipy", "matplotlib", "holidays",
+                "pandas_market_calendars", "openpyxl", "colorlog",
+                "scikit-learn"
+]
+#dependencies = ["pyperclip", "tensorflow", "scikit-learn",
+# "tensorflow_probability", "silence_tensorflow"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["sdevpy*"] # Only include these
+exclude = ["sdevpy/volatility/impliedvol/models/tssvi2*"]
+#exclude = ["notebooks*", "spreadsheets*"] # Exclude these
+
+[tool.setuptools.package-data]
+"sdevpy" = ["datasets/**/*", "notebooks/**/*.ipynb"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py313"
+
+[tool.ruff.lint]
+select = ["E", "F", "N", "W", "UP", "B"]
+ignore = ["E401", "I001"]
+
+[project.urls]
+"Git page" = "https://github.com/sebgur/SDev.Python"
+"SDev Finance" = "http://sdev-finance.com/"

sdevpy-1.0.8/sdevpy/__init__.py

@@ -0,0 +1,21 @@
+__version__ = '1.0.5'
+
+import logging
+import colorlog
+
+handler = colorlog.StreamHandler()
+handler.setFormatter(colorlog.ColoredFormatter(
+    "%(log_color)s%(levelname)-8s%(reset)s %(name)s - %(message)s",
+    log_colors={
+        "DEBUG":    "cyan",
+        "INFO":     "green",
+        "WARNING":  "yellow",
+        "ERROR":    "red",
+        "CRITICAL": "bold_red",
+    }
+))
+
+root = logging.getLogger()
+root.addHandler(handler)
+root.setLevel(logging.WARNING)
+logging.getLogger("sdevpy").setLevel(logging.DEBUG)

{sdevpy-1.0.6 → sdevpy-1.0.8}/sdevpy/analytics/americantree.py

@@ -4,17 +4,18 @@ import time
 import matplotlib.pyplot as plt
 from sdevpy.analytics import black
 from sdevpy.tree import trees
+from sdevpy.tree.trees import Payoff
 
 
-def option_price(ttm, strike, is_call, is_american, spot, vol, rf_rate, div_rate, disc_rate,
-                 method='trinomial', n_steps = 30):
+def option_price(ttm: float, strike: float, is_call: bool, is_american: bool, spot: float, vol: float,
+                 rf_rate: float, div_rate: float, disc_rate: float, method: str='trinomial', n_steps: int=30):
     """ Price of an American option using binomial or trinomial trees under Black-Scholes model """
     payoff = Payoff(ttm, strike, is_call, is_american)
     return price(payoff, spot, vol, rf_rate, div_rate, disc_rate, method, n_steps)
 
 
-def price(payoff, spot, vol, rf_rate, div_rate, disc_rate,
-          method='trinomial', n_steps = 30):
+def price(payoff, spot: float, vol: float, rf_rate: float, div_rate: float, disc_rate: float,
+          method: str='trinomial', n_steps: int=30):
     """ Price of a payoff using binomial or trinomial trees under Black-Scholes model """
     if method == 'binomial':
         tree = trees.BinomialTree(n_steps)
@@ -85,7 +86,6 @@ if __name__ == "__main__":
         bin_p = [100.0 * (x / cf - 1.0) for x in bin_p]
         tri_p = [100.0 * (x / cf - 1.0) for x in tri_p]
 
-
     # Plot the results
     plt.figure(figsize=(10, 6))
     plt.plot(bin_t, bin_p, label='Binomial Tree Price')
@@ -93,11 +93,10 @@ if __name__ == "__main__":
     if not payoff.is_american:
         plt.plot(cf_t, cf_p, label='Vanilla CF Price')
     # # plt.plot(steps_range, trinomial_prices, label='Trinomial Tree Price')
-    # plt.hlines(bs_price, steps_range[0], steps_range[-1], colors='r', linestyles='dashed', label='Black-Scholes Price')
+    # plt.hlines(bs_price, steps_range[0], steps_range[-1], colors='r', linestyles='dashed',
+    #            label='Black-Scholes Price')
     plt.title('Convergence to Black-Scholes Price for Call Options')
     plt.xlabel('Runtime')
     plt.ylabel('Option Price')
     plt.legend()
     plt.show()
-
-

sdevpy-1.0.8/sdevpy/analytics/bachelier.py

@@ -0,0 +1,140 @@
+""" Utilities for Bachelier model """
+import numpy as np
+import numpy.typing as npt
+from scipy.stats import norm
+from scipy.optimize import minimize_scalar
+
+
+def price(expiry: npt.ArrayLike, strike: npt.ArrayLike, is_call: npt.ArrayLike, fwd: npt.ArrayLike,
+          vol: npt.ArrayLike) -> npt.ArrayLike:
+    """ Option price under the Bachelier model """
+    stdev = vol * expiry**0.5
+    d = (fwd - strike) / stdev
+    wd = np.where(is_call, d, -d)
+    # wd = d if is_call else -d
+    return stdev * (wd * norm.cdf(wd) + norm.pdf(d))
+
+
+def price_straddles(expiry: npt.ArrayLike, strike: npt.ArrayLike, fwd: npt.ArrayLike,
+                    vol: npt.ArrayLike) -> npt.ArrayLike:
+    """ Straddle price under the Bachelier model.
+        Note: we could improve the speed by writing the code in-line instead of
+              calling the price() function twice """
+    expiries_ = np.asarray(expiry).reshape(-1, 1)
+    prices = []
+    for i, exp_row in enumerate(expiries_):
+        k_prices = []
+        for j, k in enumerate(strike[i]):
+            iv = vol[i, j]
+            call_price = price(exp_row, k, True, fwd, iv)
+            put_price = price(exp_row, k, False, fwd, iv)
+            k_prices.append(call_price[0] + put_price[0])
+        prices.append(k_prices)
+
+    return np.asarray(prices)
+
+
+def implied_vol_jaeckel(expiry: float, strike: float, is_call: bool, fwd: float, fwd_price: float) -> float:
+    """ P. Jaeckel's method in "Implied Normal Volatility", 6th Jun. 2017.
+        This is the original, non-vectorized. """
+    m = fwd - strike
+    abs_m = np.abs(m)
+    # Special case at ATM
+    if abs_m < 1e-8:
+        return fwd_price * np.sqrt(2.0 * np.pi) / np.sqrt(expiry)
+
+    # General case
+    tilde_phi_star_c = -0.001882039271
+    theta = 1.0 if is_call else -1.0
+
+    tilde_phi_star = -np.abs(fwd_price - np.maximum(theta * m, 0.0)) / abs_m
+    em5 = 1e-5
+
+    if tilde_phi_star < tilde_phi_star_c:
+        g = 1.0 / (tilde_phi_star - 0.5)
+        g2 = g**2
+        em3 = 1e-3
+        num = 0.032114372355 - g2 * (0.016969777977 - g2 * (2.6207332461 * em3
+                                                             - 9.6066952861 * em5 * g2))
+        den = 1.0 - g2 * (0.6635646938 - g2 * (0.14528712196 - 0.010472855461 * g2))
+        eta_bar = num / den
+        xb = g * (eta_bar * g2 + 1.0 / np.sqrt(2.0 * np.pi))
+    else:
+        h = np.sqrt(-np.log(-tilde_phi_star))
+        num = 9.4883409779 - h * (9.6320903635 - h * (0.58556997323 + 2.1464093351 * h))
+        den = 1.0 - h * (0.65174820867 + h * (1.5120247828 + 6.6437847132 * em5 * h))
+        xb = num / den
+
+    q = (norm.cdf(xb) + norm.pdf(xb) / xb - tilde_phi_star) / norm.pdf(xb)
+    xb2 = xb**2
+    num = 3.0 * q * xb2 * (2.0 - q * xb * (2.0 + xb2))
+    den = 6.0 + q * xb * (-12.0 + xb * (6.0 * q + xb * (-6.0 + q * xb * (3.0 + xb2))))
+    xs = xb + num / den
+    sigma = abs_m / (np.abs(xs) * np.sqrt(expiry))
+    return sigma
+
+
+def implied_vol(expiry: npt.ArrayLike, strike: npt.ArrayLike, is_call: npt.ArrayLike,
+                fwd: npt.ArrayLike, fwd_price: npt.ArrayLike) -> npt.NDArray[np.float64]:
+    """ P. Jaeckel's method in "Implied Normal Volatility", 6th Jun. 2017.
+        Vectorized version (vectorization not in Jaeckel). """
+    strike = np.asarray(strike, dtype=float)
+    fwd_price = np.asarray(fwd_price, dtype=float)
+    is_call = np.asarray(is_call, dtype=bool)
+
+    #### ATM branch ####
+    m = fwd - strike
+    abs_m = np.abs(m)
+    atm_mask = (abs_m < 1e-8)
+    atm_result = fwd_price * np.sqrt(2.0 * np.pi / expiry)
+
+    #### General case ####
+    tilde_phi_star_c = -0.001882039271
+    theta = np.where(is_call, 1.0, -1.0)
+    tilde_phi_star = -np.abs(fwd_price - np.maximum(theta * m, 0.0)) / np.where(atm_mask, 1.0, abs_m)
+    em5 = 1e-5
+    mask_low = (tilde_phi_star < tilde_phi_star_c)
+
+    # Branch = lower
+    g = 1.0 / (tilde_phi_star - 0.5)
+    g2 = g**2
+    em3 = 1e-3
+    num_low = 0.032114372355 - g2 * (0.016969777977 - g2 * (2.6207332461 * em3 - 9.6066952861 * em5 * g2))
+    den_low = 1.0 - g2 * (0.6635646938 - g2 * (0.14528712196 - 0.010472855461 * g2))
+    eta_bar = num_low / den_low
+    xb_low = g * (eta_bar * g2 + 1.0 / np.sqrt(2.0 * np.pi))
+
+    # Branch = higher
+    # Note: substitute a safe value where mask_low is True to avoid sqrt(log(large))
+    safe_tps = np.where(mask_low, -0.001, tilde_phi_star)
+    h = np.sqrt(-np.log(-safe_tps))
+    num_high = 9.4883409779 - h * (9.6320903635 - h * (0.58556997323 + 2.1464093351 * h))
+    den_high = 1.0 - h * (0.65174820867 + h * (1.5120247828 + 6.6437847132 * em5 * h))
+    xb_high = num_high / den_high
+
+    # Join lower/higher
+    xb = np.where(mask_low, xb_low, xb_high)
+    q = (norm.cdf(xb) + norm.pdf(xb) / xb - tilde_phi_star) / norm.pdf(xb)
+    xb2 = xb**2
+    num = 3.0 * q * xb2 * (2.0 - q * xb * (2.0 + xb2))
+    den = 6.0 + q * xb * (-12.0 + xb * (6.0 * q + xb * (-6.0 + q * xb * (3.0 + xb2))))
+    xs = xb + num / den
+    sigma = abs_m / (np.abs(xs) * np.sqrt(expiry))
+
+    # Join ATM/OTM
+    return np.where(atm_mask, atm_result, sigma)
+
+
+def implied_vol_solve(expiry: float, strike: float, is_call: bool, fwd: float, fwd_price: float) -> float:
+    """ Direct method by numerical inversion using Brent """
+    options = {'xtol': 1e-4, 'maxiter': 100, 'disp': False}
+    xmin = 1e-6
+    xmax = 1.0
+
+    def error(vol):
+        premium = price(expiry, strike, is_call, fwd, vol)
+        return (premium - fwd_price) ** 2
+
+    res = minimize_scalar(fun=error, bracket=(xmin, xmax), options=options, method='brent')
+
+    return res.x

sdevpy-1.0.8/sdevpy/analytics/black.py

@@ -0,0 +1,105 @@
+""" Utilities for Black-Scholes model """
+import numpy as np
+import numpy.typing as npt
+from scipy.stats import norm
+from scipy.optimize import minimize_scalar
+from sdevpy.thirdparty.py_vollib.black import implied_volatility as jaeckel
+from sdevpy.utilities.tools import isiterable
+
+
+def price(expiry: npt.ArrayLike, strike: npt.ArrayLike, is_call: npt.ArrayLike, fwd: npt.ArrayLike,
+          vol: npt.ArrayLike) -> npt.NDArray[np.float64]:
+    """ Option price under the Black-Scholes model """
+    # w = 1.0 if is_call else -1.0
+    w = np.where(is_call, 1.0, -1.0)
+    s = vol * np.sqrt(expiry)
+    d1 = np.log(fwd / strike) / s + 0.5 * s
+    d2 = d1 - s
+    return w * (fwd * norm.cdf(w * d1) - strike * norm.cdf(w * d2))
+
+
+def implied_vol(expiry: float, strike: float, is_call: bool, fwd: float, fwd_price: float) -> float:
+    """ Direct method by numerical inversion using Brent.
+        Non-vectorized due to solver. """
+    options = {'xtol': 1e-4, 'maxiter': 100, 'disp': False}
+    xmin = 1e-6
+    xmax = 1.0
+
+    def error(vol):
+        premium = price(expiry, strike, is_call, fwd, vol)
+        return (premium - fwd_price) ** 2
+
+    res = minimize_scalar(fun=error, bracket=(xmin, xmax), options=options, method='brent')
+    return res.x
+
+
+def implied_vols(expiry: float, strike: npt.ArrayLike, is_call: bool, fwd: float,
+                 fwd_price: npt.ArrayLike) -> npt.ArrayLike:
+    """ Black implied volatility for vector of strikes/prices """
+    if isiterable(strike) and isiterable(fwd_price):
+        ivs = [implied_vol(expiry, k, is_call, fwd, p) for k, p in zip(strike, fwd_price, strict=True)]
+        return np.asarray(ivs)
+    elif not isiterable(strike) and not isiterable(fwd_price):
+        return implied_vol(expiry, strike, is_call, fwd, fwd_price)
+    else:
+        raise ValueError("Incompatible shapes between strikes and prices")
+
+
+def implied_vol_newton(expiry: float, strike: npt.ArrayLike, is_call: bool, fwd: float,
+                       fwd_price: npt.ArrayLike, tol: float=1e-8, max_iter: int=50) -> npt.ArrayLike:
+    """ Using vectorized Newton-Raphson, with faster convergence than Brent.
+        However, this method can struggle for very small vegas, so we may want to switch
+        to another method (maybe Brent above) below a certain vega threshold.
+        Or to switch to Halley's method.
+        To be investigated if speed becomes a bottleneck or Brent's method has issues. """
+    strike = np.asarray(strike, dtype=float)
+    fwd_price = np.asarray(fwd_price, dtype=float)
+    vol = np.full_like(fwd_price, 0.25) # Initial guess: flat 25%
+    sqrt_t = np.sqrt(expiry)
+    for _ in range(max_iter):
+        s = vol * sqrt_t
+        d1 = np.log(fwd / strike) / s + 0.5 * s
+        vega = fwd * norm.pdf(d1) * sqrt_t
+        diff = price(expiry, strike, is_call, fwd, vol) - fwd_price
+        vol -= diff / vega
+        vol = np.maximum(vol, 1e-8) # Keep vol positive
+        if np.all(np.abs(diff) < tol):
+            break
+
+    # if len(strike) == 1 and len(fwd_price) == 1 and len(vol) == 1: # Return a scalar if inputs are scalar
+    #     return vol[0]
+    # else:
+    #     return vol
+    return (vol.item() if vol.ndim == 0 or vol.size ==1 else vol)
+
+
+def implied_vol_jaeckel(expiry: float, strike: float, is_call: bool, fwd: float, fwd_price: float) -> float:
+    """ Black-Scholes implied volatility using P. Jaeckel's 'Let's be rational' method,
+        from package py_vollib. Install with pip install py_vollib or at
+        https://pypi.org/project/py_vollib/. Unfortunately we found it has instabilities
+        near ATM. """
+    flag = 'c' if is_call else 'p'
+    p = fwd_price
+    iv = jaeckel.implied_volatility_of_undiscounted_option_price(p, fwd, strike, expiry, flag)
+    return iv
+
+
+if __name__ == "__main__":
+    EXPIRY = 1.0
+    VOL = 0.25
+    IS_CALL = True
+    NUM_POINTS = 100
+    # FWD = 100
+    # K = 100
+    # p = price(EXPIRY, K, IS_CALL, FWD, VOL)
+    # iv = implied_vol(EXPIRY, K, IS_CALL, FWD, p)
+    # print(iv)
+    f_space = np.linspace(100, 120, NUM_POINTS)
+    k_space = np.linspace(20, 2180, NUM_POINTS)
+    prices = price(EXPIRY, k_space, IS_CALL, f_space, VOL)
+    # print(prices)
+    implied_vols = []
+    for i, k in enumerate(k_space):
+        implied_vols.append(implied_vol(EXPIRY, k, IS_CALL, f_space[i], prices[i]))
+
+    # print(implied_vols)

sdevpy-1.0.8/sdevpy/cointegration/back_testing.py

@@ -0,0 +1,224 @@
+import numpy as np
+import pandas as pd
+# import statsmodels.api as sm
+# from sdevpy.cointegration import coint_trading as ct
+from sdevpy.cointegration import utils as ut
+# from sdevpy.cointegration import data_io as myio
+# from sdevpy.cointegration import mean_reversion as my_mean_rev
+import math
+from tqdm import tqdm # for console progress bar
+
+# input string
+# "['EURUSD Curncy', 'GBPUSD Curncy', 'JPYUSD Curncy', 'SGDUSD Curncy', 'CNHUSD Curncy']"
+# we need to remove all "[", "]" and "'", then split by "," and then create a list
+def name_list_string_to_name_list(name_list_str):
+    res_str = name_list_str.replace(" '", "")
+    res_str = res_str.replace("'", "")
+    res_str = res_str.replace('[', '')
+    res_str = res_str.replace(']', '')
+    name_list = list(res_str.split(','))
+    return name_list
+
+
+def weigths_list_string_to_float_list(weigths_list_str):
+    res_str = weigths_list_str.replace('[', '')
+    res_str = res_str.replace(']', '')
+    float_list = [float(idx) for idx in res_str.split(',')]
+    return float_list
+
+
+# Given a fixed basket, from date, trade date, now date
+# compute the sharpe ratio, z_score, 5D realized return and 10D realized return from trade date
+def back_test_one_trade(from_, trade_date, now, name_list, weights_xxxusd, zscore_trade_date, df_fx_spot):
+    df_fx_name_list_xxxusd = df_fx_spot[name_list]
+
+    # compute the basket up to NOW, because we need to compute the realized 5D and 10D returns
+    basket_up_to_now = ut.compute_basket(df_fx_name_list_xxxusd.loc[from_:now], weights_xxxusd)
+
+    # compute the stdev as if we were on the TRADE DATE, this is used for computing the return in terms of ZScore
+    stdev_up_to_trade_date = np.std(basket_up_to_now.loc[:trade_date])
+
+    basket_from_trade_date_to_now = basket_up_to_now.loc[trade_date:now]
+
+    basket_2d_rtns_from_trade_date = ut.compute_x_day_historical_returns_in_SD(basket_from_trade_date_to_now, 2,
+     stdev_up_to_trade_date).iloc[0]
+    basket_5d_rtns_from_trade_date = ut.compute_x_day_historical_returns_in_SD(basket_from_trade_date_to_now, 5,
+     stdev_up_to_trade_date).iloc[0]
+    basket_10d_rtns_from_trade_date = ut.compute_x_day_historical_returns_in_SD(basket_from_trade_date_to_now, 10,
+     stdev_up_to_trade_date).iloc[0]
+
+    min_max_res_2d = ut.min_max_return_x_days_in_SD(basket_from_trade_date_to_now, 2, stdev_up_to_trade_date).iloc[0]
+    min_2d_rtns_in_sd = min_max_res_2d['min']
+    max_2d_rtns_in_sd = min_max_res_2d['max']
+
+    min_max_res_5d = ut.min_max_return_x_days_in_SD(basket_from_trade_date_to_now, 5, stdev_up_to_trade_date).iloc[0]
+    min_5d_rtns_in_sd = min_max_res_5d['min']
+    max_5d_rtns_in_sd = min_max_res_5d['max']
+
+    min_max_res_10d = ut.min_max_return_x_days_in_SD(basket_from_trade_date_to_now, 10, stdev_up_to_trade_date).iloc[0]
+    min_10d_rtns_in_sd = min_max_res_10d['min']
+    max_10d_rtns_in_sd = min_max_res_10d['max']
+
+    if math.isnan(basket_10d_rtns_from_trade_date):
+        raise Exception('Trade DATE is less than 10 days ago.')
+
+    if zscore_trade_date > 0:
+        # flip the return sign if zscore is above 0, because we sell. The basket goes down and we earn
+        basket_2d_rtns_from_trade_date = -basket_2d_rtns_from_trade_date
+        basket_5d_rtns_from_trade_date = -basket_5d_rtns_from_trade_date
+        basket_10d_rtns_from_trade_date = -basket_10d_rtns_from_trade_date
+
+        # so the max draw down is the negative of the max returns
+        max_2d_draw_down_in_sd = -max_2d_rtns_in_sd
+        max_5d_draw_down_in_sd = -max_5d_rtns_in_sd
+        max_10d_draw_down_in_sd = -max_10d_rtns_in_sd
+    else:
+        # we buy so that max draw down is teh min returns
+        max_2d_draw_down_in_sd = min_2d_rtns_in_sd
+        max_5d_draw_down_in_sd = min_5d_rtns_in_sd
+        max_10d_draw_down_in_sd = min_10d_rtns_in_sd
+
+    #if the max draw down is a positive number, we floor it to 0 to show there is no loss
+    max_2d_draw_down_in_sd = np.minimum(max_2d_draw_down_in_sd, 0.0)
+    max_5d_draw_down_in_sd = np.minimum(max_5d_draw_down_in_sd, 0.0)
+    max_10d_draw_down_in_sd = np.minimum(max_10d_draw_down_in_sd, 0.0)
+
+    res_dict = {'2D Realized Rtns from Trade Date in SD': basket_2d_rtns_from_trade_date,
+                '5D Realized Rtns from Trade Date in SD': basket_5d_rtns_from_trade_date,
+                '10D Realized Rtns from Trade Date in SD': basket_10d_rtns_from_trade_date,
+                '2D max draw down in SD': max_2d_draw_down_in_sd,
+                '5D max draw down in SD': max_5d_draw_down_in_sd,
+                '10D max draw down in SD': max_10d_draw_down_in_sd,
+                'basket stdev on Trade Date': stdev_up_to_trade_date
+                }
+
+    return res_dict
+
+# res_df_filtered - output from coint_trading.filter_cointegration_basket
+def back_test_many_trades(res_df_filtered, now, df_fx_spot):
+    back_test_res = []
+
+    num_rows = len(res_df_filtered)
+
+    for idx in tqdm(range(num_rows)):
+        from_ = res_df_filtered['From'].iloc[idx]
+        trade_date = res_df_filtered['Today'].iloc[idx]
+        trade_date = pd.to_datetime(trade_date, format='%Y-%m-%d')
+
+        name_str = res_df_filtered['currency pairs'].iloc[idx]
+        name_list = name_list_string_to_name_list(name_str)
+
+        weights_xxxusd_str = res_df_filtered['unadj weights in xxxusd'].iloc[idx]
+        weights_xxxusd = weigths_list_string_to_float_list(weights_xxxusd_str)
+
+        sharpe_5d = res_df_filtered['5D Sharpe Ratio'].iloc[idx]
+        sd_on_trade_date = res_df_filtered['SD Current'].iloc[idx]
+
+        stop_loss_in_sd = res_df_filtered['Stop Loss in SD'].iloc[idx]
+
+        half_life_in_days = res_df_filtered['half life in days'].iloc[idx]
+
+        range_in_sd_current = res_df_filtered['Range in SD current'].iloc[idx]
+
+        abs_sd_on_trade_date = np.abs(sd_on_trade_date)
+
+        one_month_trace_5pct = res_df_filtered['+/- 1 month trace (5%)'].iloc[idx]
+        one_month_trace_10pct = res_df_filtered['+/- 1 month trace (10%)'].iloc[idx]
+        one_month_eigen_5pct = res_df_filtered['+/- 1 month eigen (5%)'].iloc[idx]
+        one_month_eigen_10pct = res_df_filtered['+/- 1 month eigen (10%)'].iloc[idx]
+
+        res_dict = back_test_one_trade(from_, trade_date, now, name_list, weights_xxxusd,
+                                       sd_on_trade_date, df_fx_spot)
+
+        basket_stdev = res_dict['basket stdev on Trade Date']
+
+        mean_rev_level = res_df_filtered['mean_rev_level'].iloc[idx]
+
+        back_test_res.append((from_, trade_date, now, name_list, weights_xxxusd, sharpe_5d,
+                              sd_on_trade_date, abs_sd_on_trade_date, stop_loss_in_sd,
+                              res_dict['2D Realized Rtns from Trade Date in SD'],
+                              res_dict['5D Realized Rtns from Trade Date in SD'],
+                              res_dict['10D Realized Rtns from Trade Date in SD'],
+                              res_dict['2D max draw down in SD'],
+                              res_dict['5D max draw down in SD'],
+                              res_dict['10D max draw down in SD'],
+                              basket_stdev, mean_rev_level, half_life_in_days, range_in_sd_current,
+                              one_month_trace_5pct, one_month_trace_10pct,
+                              one_month_eigen_5pct, one_month_eigen_10pct))
+
+        #--- end of for ind in tqdm(res_df_filtered.index):
+
+    res_df = pd.DataFrame(back_test_res, columns =['from_', 'Trade Date', 'Now', 'currency pairs',
+                                                   'unadj weights in xxxusd', 'Sharpe Ratio on Trade Date',
+                                                   'Z Score on Trade Date', 'Abs Z Score on Trade Date',
+                                                   'Distance to max/min SD', '2D Realized Rtns in SD',
+                                                   '5D Realized Rtns in SD', '10D Realized Rtns in SD',
+                                                   '2D max DD in SD', '5D max DD in SD', '10D max DD in SD',
+                                                   'basket stdev on Trade Date', 'mean_rev_level on Trade Date',
+                                                   'half life in days', 'Range in SD current',
+                                                   '+/- 1 month trace (5%)', '+/- 1 month trace (10%)',
+                                                   '+/- 1 month eigen (5%)', '+/- 1 month eigen (10%)'])
+
+    return res_df
+
+# Take the results of back_test_many_trades and then compute the back test diagnostics
+def one_back_test_summary_table(back_test_res_df, start_date, end_date, sharpe_threshold, zscore_threshold):
+    upper_sd_condition = back_test_res_df['Z Score on Trade Date'] > zscore_threshold
+    lower_sd_condition = back_test_res_df['Z Score on Trade Date'] < -zscore_threshold
+    sharpe_condition = back_test_res_df['Sharpe Ratio on Trade Date'] > sharpe_threshold
+
+    start_date_condition = back_test_res_df['Trade Date'] > pd.Timestamp(start_date)
+    end_date_condition = back_test_res_df['Trade Date'] < pd.Timestamp(end_date)
+
+    # -----------apply conditions
+    my_trade_df = back_test_res_df[sharpe_condition]
+    my_trade_df = my_trade_df[upper_sd_condition | lower_sd_condition]
+    my_trade_df = my_trade_df[start_date_condition]
+    my_trade_df = my_trade_df[end_date_condition]
+
+    total = len(my_trade_df)
+
+    output_table = []
+
+    column_list = ['2D Realized Rtns in SD', '5D Realized Rtns in SD', '10D Realized Rtns in SD']
+
+    for column in column_list:
+        positive_return_condition = my_trade_df[column] > 0.0
+        num_pos_rtn = len(my_trade_df[positive_return_condition])
+        num_neg_rtn = len(my_trade_df[~positive_return_condition])
+
+        pos_rtn_pct = round(num_pos_rtn/total, 3)
+        neg_rtn_pct = round(num_neg_rtn/total, 3)
+
+        rtns_median = np.median(my_trade_df[column])
+        rtns_mean = np.mean(my_trade_df[column])
+        rtns_std = np.std(my_trade_df[column])
+
+        first_3_char = column[:3]
+
+        output_table.append((start_date,
+                             end_date,
+                             sharpe_threshold,
+                             zscore_threshold,
+                             first_3_char,
+                             pos_rtn_pct,
+                             neg_rtn_pct,
+                             total,
+                             rtns_median,
+                             rtns_mean,
+                             rtns_std))
+
+    res_df = pd.DataFrame(output_table, columns =['Period Start',
+                                                  'Period End',
+                                                  'Sharpe threshold',
+                                                  'SD threshold',
+                                                  'Rtns type',
+                                                  'Pos %',
+                                                  'Neg %',
+                                                  'Total',
+                                                  'Rtns median',
+                                                  'Rtns mean',
+                                                  'Rtns stdev'
+                                                  ])
+
+    return res_df, my_trade_df