qis 3.1.4__tar.gz → 3.1.6__tar.gz

{qis-3.1.4 → qis-3.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qis
-Version: 3.1.4
+Version: 3.1.6
 Summary: Implementation of visualisation and reporting analytics for Quantitative Investment Strategies
 License: LICENSE.txt
 Keywords: quantitative,investing,portfolio optimization,systematic strategies,volatility

{qis-3.1.4 → qis-3.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "qis"
-version = "3.1.4"
+version = "3.1.6"
 description = "Implementation of visualisation and reporting analytics for Quantitative Investment Strategies"
 license = "LICENSE.txt"
 authors = ["Artur Sepp <artursepp@gmail.com>"]

{qis-3.1.4 → qis-3.1.6}/qis/examples/factsheets/strategy_benchmark.py

@@ -18,9 +18,10 @@ from qis.portfolio.reports.strategy_benchmark_factsheet import (generate_strateg
                                                                 generate_strategy_benchmark_active_perf_plt,
                                                                 generate_performance_attribution_report,
                                                                 weights_tracking_error_report_by_ac_subac)
+from qis.test_data import load_etf_data
 
 
-def fetch_universe_data() -> Tuple[pd.DataFrame, pd.DataFrame, pd.Series]:
+def fetch_universe_data(live_prices: bool = True) -> Tuple[pd.DataFrame, pd.DataFrame, pd.Series]:
     """
     define custom universe with asset class grouping
     """
@@ -34,10 +35,11 @@ def fetch_universe_data() -> Tuple[pd.DataFrame, pd.DataFrame, pd.Series]:
                          GLD='Gold')
     tickers = list(universe_data.keys())
     group_data = pd.Series(universe_data)  # for portfolio reporting
-    # prices = yf.download(tickers=tickers, start=None, end=None, ignore_tz=True)['Close'][tickers]
-    from qis.test_data import load_etf_data
-    prices = load_etf_data()[tickers]
-    print(prices)
+    if live_prices:
+        prices = yf.download(tickers=tickers, start=None, end=None, ignore_tz=True)['Close'][tickers]
+    else:
+        prices = load_etf_data()[tickers]
+        print(prices)
 
     prices = prices.asfreq('B', method='ffill')
     benchmark_prices = prices[['SPY', 'TLT']]
@@ -92,7 +94,6 @@ def run_unit_test(unit_test: UnitTests):
     time_period = qis.TimePeriod('31Dec2006', '10Jan2025')
     prices, benchmark_prices, group_data = fetch_universe_data()
 
-
     multi_portfolio_data = generate_volparity_multiportfolio(prices=prices,
                                                              benchmark_prices=benchmark_prices,
                                                              group_data=group_data,
@@ -157,7 +158,7 @@ def run_unit_test(unit_test: UnitTests):
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.TRACKING_ERROR
+    unit_test = UnitTests.STRATEGY_BENCHMARK_PLT
 
     is_run_all_tests = False
     if is_run_all_tests:

{qis-3.1.4 → qis-3.1.6}/qis/models/linear/ewm.py

@@ -606,6 +606,7 @@ def compute_ewm_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
                     ) -> Union[pd.DataFrame, pd.Series, np.ndarray]:
     """
     implementation of ewm recursion for variance/volatility computation
+    vol_floor_quantile_roll_period will replace ewma estimate with quantile vol if vol < quantile vol
     """
     a = npo.to_finite_np(data=data, fill_value=np.nan)
 
@@ -634,7 +635,9 @@ def compute_ewm_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
     # apply quantile
     if vol_floor_quantile is not None:
         ewm_pd = pd.DataFrame(ewm)
-        ewm_quantiles = ewm_pd.rolling(vol_floor_quantile_roll_period, min_periods=100).quantile(vol_floor_quantile, interpolation="lower")
+        ewm_quantiles = ewm_pd.rolling(vol_floor_quantile_roll_period,
+                                       min_periods=int(0.2*vol_floor_quantile_roll_period)
+                                       ).quantile(vol_floor_quantile, interpolation="lower")
         vol_floor = ewm_quantiles.to_numpy()
         ewm = np.where(np.less(ewm, vol_floor), vol_floor, ewm)
 
@@ -657,7 +660,86 @@ def compute_ewm_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
         ewm = pd.DataFrame(data=ewm, index=data.index, columns=data.columns)
     elif isinstance(data, pd.Series):
         ewm = pd.Series(data=ewm, index=data.index, name=data.name)
+    return ewm
+
+
+def compute_ewm_newey_west_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
+                               num_lags: int = 3,
+                               span: Optional[Union[float, np.ndarray]] = None,
+                               ewm_lambda: Union[float, np.ndarray] = 0.94,
+                               mean_adj_type: MeanAdjType = MeanAdjType.NONE,
+                               init_type: InitType = InitType.X0,
+                               init_value: Optional[Union[float, np.ndarray]] = None,
+                               apply_sqrt: bool = True,
+                               annualize: bool = False,
+                               af: Optional[float] = None,
+                               warmup_period: Optional[int] = None,
+                               nan_backfill: NanBackfill = NanBackfill.FFILL
+                               ) -> Union[pd.DataFrame, pd.Series, np.ndarray]:
+    """
+    implementation of newey west vol estimator
+    implementation of ewm recursion for variance/volatility computation
+    vol_floor_quantile_roll_period will replace ewma estimate with quantile vol if vol < quantile vol
+    """
+    a = npo.to_finite_np(data=data, fill_value=np.nan)
+
+    if span is not None:
+        ewm_lambda = 1.0 - 2.0 / (span + 1.0)
+
+    if mean_adj_type != MeanAdjType.NONE:
+        a = compute_rolling_mean_adj(data=a,
+                                     mean_adj_type=mean_adj_type,
+                                     ewm_lambda=ewm_lambda,
+                                     init_type=init_type,
+                                     nan_backfill=nan_backfill)
+
+    # initial conditions
+    a = a
+    if init_value is None:
+        init_value = set_init_dim1(data=a, init_type=init_type)
+
+    if isinstance(data, pd.Series) or (isinstance(data, np.ndarray) and data.ndim == 1):
+        ewm_lambda = float(ewm_lambda)
+        if isinstance(init_value, np.ndarray):
+            init_value = float(init_value)
+
+    ewm0 = ewm_recursion(a=a, ewm_lambda=ewm_lambda, init_value=init_value, nan_backfill=nan_backfill)
+
+
+    # compute m recursions:
+    ewms = {}
+    for m in np.arange(num_lags):
+        # lagged value
+        if m == 0:
+            a_m = a
+        else:
+            a_m = np.empty_like(a)
+            a_m[m:] = a[:-m]
+            a_m[:m] = np.nan
+        ewms[m] = ewm_recursion(a=a*a_m, ewm_lambda=ewm_lambda, init_value=init_value, nan_backfill=nan_backfill)
+
+    ewm_
+
+
+    if warmup_period is not None:   # set to nan first nonnan in warmup_period
+        ewm = npo.set_nans_for_warmup_period(a=ewm, warmup_period=warmup_period)
+
+    if annualize or af is not None:
+        if af is None:
+            if isinstance(data, pd.DataFrame) or isinstance(data, pd.Series):
+                af = da.infer_an_from_data(data=data)
+            else:
+                warnings.warn(f"in compute_ewm  annualization_factor for np array default is 1")
+                af = 1.0
+        ewm = af * ewm
 
+    if apply_sqrt:
+        ewm = np.sqrt(ewm)
+
+    if isinstance(data, pd.DataFrame):
+        ewm = pd.DataFrame(data=ewm, index=data.index, columns=data.columns)
+    elif isinstance(data, pd.Series):
+        ewm = pd.Series(data=ewm, index=data.index, name=data.name)
     return ewm
 
 

{qis-3.1.4 → qis-3.1.6}/qis/perfstats/config.py

@@ -114,6 +114,7 @@ class PerfStat(ColVar, Enum):
     ALPHA_AN = ColVar(name='An Alpha', short_n='Alpha', value_type=ValueType.PERCT)
     BETA = ColVar(name='Beta', short_n='Beta', value_type=ValueType.FLOAT2)
     R2 = ColVar(name='R2', short_n='R2', value_type=ValueType.PERCT0)
+    ALPHA_PVALUE = ColVar(name='p-Alpha', short_n='p-Alpha', value_type=ValueType.FLOAT2)
 
 
 """

{qis-3.1.4 → qis-3.1.6}/qis/perfstats/perf_stats.py

@@ -101,7 +101,8 @@ BENCHMARK_TABLE_COLUMNS = (PerfStat.PA_RETURN,
                            PerfStat.SKEWNESS,
                            PerfStat.ALPHA_AN,
                            PerfStat.BETA,
-                           PerfStat.R2)
+                           PerfStat.R2,
+                           PerfStat.ALPHA_PVALUE)
 
 BENCHMARK_TABLE_COLUMNS2 = (PerfStat.TOTAL_RETURN,
                             PerfStat.PA_RETURN,
@@ -271,14 +272,14 @@ def compute_ra_perf_table_with_benchmark(prices: pd.DataFrame,
     if perf_params.rates_data is not None:
         returns = ret.compute_excess_returns(returns=returns, rates_data=perf_params.rates_data)
 
-    alphas, betas, r2 = {}, {}, {}
+    alphas, betas, r2, alpha_pvalue = {}, {}, {}, {}
     for column in returns.columns:
         joint_data = returns[[benchmark, column]].dropna()
         if joint_data.empty or len(joint_data.index) < 2:
-            alphas[column], betas[column], r2[column] = np.nan, np.nan, np.nan
+            alphas[column], betas[column], r2[column], alpha_pvalue[column] = np.nan, np.nan, np.nan, np.nan
         else:
-            alphas[column], betas[column], r2[column] = ols.estimate_ols_alpha_beta(x=joint_data.iloc[:, 0],
-                                                                                    y=joint_data.iloc[:, 1])
+            alphas[column], betas[column], r2[column], alpha_pvalue[column] = ols.estimate_ols_alpha_beta(x=joint_data.iloc[:, 0],
+                                                                                                          y=joint_data.iloc[:, 1])
 
             # get vol and compute risk adjusted performance
     alpha_an_factor = alpha_an_factor or perf_params.alpha_an_factor
@@ -286,9 +287,12 @@ def compute_ra_perf_table_with_benchmark(prices: pd.DataFrame,
     ra_perf_table[PerfStat.ALPHA_AN.to_str()] = alpha_an_factor * pd.Series(alphas)
     ra_perf_table[PerfStat.BETA.to_str()] = pd.Series(betas)
     ra_perf_table[PerfStat.R2.to_str()] = pd.Series(r2)
+    ra_perf_table[PerfStat.ALPHA_PVALUE.to_str()] = pd.Series(alpha_pvalue)
 
     if drop_benchmark:
         ra_perf_table = ra_perf_table.drop([benchmark], axis=0)
+    else:  # set p-value of benchmark alpha to 1
+        ra_perf_table.loc[benchmark, PerfStat.ALPHA_PVALUE.to_str()] = 1.0
     return ra_perf_table
 
 

{qis-3.1.4 → qis-3.1.6}/qis/plots/derived/perf_table.py

@@ -152,7 +152,6 @@ def plot_ra_perf_table_benchmark(prices: pd.DataFrame,
             df_to_add = df_to_add.fillna('')
         ra_perf_table = pd.concat([ra_perf_table, df_to_add], axis=1)
 
-
     fig = ptb.plot_df_table(df=ra_perf_table,
                             transpose=transpose,
                             special_columns_colors=special_columns_colors,
@@ -415,7 +414,7 @@ def plot_best_worst_returns(price: pd.Series,
 class UnitTests(Enum):
     PLOT_RA_PERF_TABLE = 1
     PLOT_RA_PERF_SCATTER = 2
-    PLOT_RA_PERF_TABLE_BENCHMARKS = 3
+    PLOT_RA_PERF_TABLE_BENCHMARK = 3
     PLOT_DESC_FREQ_TABLE = 4
     PLOT_SHARPE_BARPLOT = 5
     PLOT_SHARPE_BY_DATES = 6
@@ -444,7 +443,7 @@ def run_unit_test(unit_test: UnitTests):
         plot_ra_perf_scatter(prices=prices,
                              perf_params=perf_params)
 
-    elif unit_test == UnitTests.PLOT_RA_PERF_TABLE_BENCHMARKS:
+    elif unit_test == UnitTests.PLOT_RA_PERF_TABLE_BENCHMARK:
         perf_params = PerfParams(freq='ME')
         plot_ra_perf_table_benchmark(prices=prices,
                                      benchmark='SPY',
@@ -483,7 +482,7 @@ def run_unit_test(unit_test: UnitTests):
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.PLOT_TOP_BOTTOM_RETURNS
+    unit_test = UnitTests.PLOT_RA_PERF_TABLE_BENCHMARK
 
     is_run_all_tests = False
     if is_run_all_tests:

{qis-3.1.4 → qis-3.1.6}/qis/portfolio/multi_portfolio_data.py

@@ -497,7 +497,7 @@ class MultiPortfolioData:
                 navs_ = portfolio.get_portfolio_nav(time_period=time_period)  # navs include costs while group navs are cost free
                 ac_prices_ = portfolio.get_group_navs(time_period=time_period, is_add_group_total=False)
                 strategy_prices.append(navs_)
-                if add_ac:
+                if add_ac and ac_prices_ is not None:
                     ac_prices_.columns = [f"{portfolio_name}-{x}" for x in ac_prices_.columns]
                     ac_prices.append(ac_prices_)
                     rows_edge_lines.append(sum(rows_edge_lines)+len(ac_prices_.columns))
@@ -505,7 +505,7 @@ class MultiPortfolioData:
 
             benchmark_price = benchmark_price.reindex(index=strategy_prices.index, method='ffill')
             if benchmark_price.name not in strategy_prices.columns:
-                prices = pd.concat([benchmark_price, strategy_prices], axis=1)
+                prices = pd.concat([strategy_prices, benchmark_price], axis=1)
             else:
                 prices = strategy_prices
             if add_ac:  # otherwise tables look too bad

{qis-3.1.4 → qis-3.1.6}/qis/portfolio/portfolio_data.py

@@ -215,7 +215,7 @@ class PortfolioData:
                        time_period: TimePeriod = None,
                        constant_trade_level: bool = False,
                        is_add_group_total: bool = False
-                       ) -> pd.DataFrame:
+                       ) -> Optional[pd.DataFrame]:
         """
         group total will exclude transaction costs so it is not equal to portfolio nav
         """
@@ -223,12 +223,17 @@ class PortfolioData:
             total_column = str(self.nav.name)
         else:
             total_column = None
-        grouped_pnl = dfg.agg_df_by_groups_ax1(df=self.get_instruments_pnl(time_period=time_period),
-                                               group_data=self.group_data,
-                                               agg_func=np.nansum,
-                                               total_column=total_column,
-                                               group_order=self.group_order)
-        group_navs = ret.returns_to_nav(returns=grouped_pnl, constant_trade_level=constant_trade_level)
+        df = self.get_instruments_pnl(time_period=time_period)
+        if df.empty:
+            print(f"instruments p&l is not available for time_period={time_period.to_str()}")
+            group_navs = None
+        else:
+            grouped_pnl = dfg.agg_df_by_groups_ax1(df=df,
+                                                   group_data=self.group_data,
+                                                   agg_func=np.nansum,
+                                                   total_column=total_column,
+                                                   group_order=self.group_order)
+            group_navs = ret.returns_to_nav(returns=grouped_pnl, constant_trade_level=constant_trade_level)
         return group_navs
 
     def get_total_nav_with_group_navs(self, time_period: TimePeriod = None) -> pd.DataFrame:

{qis-3.1.4 → qis-3.1.6}/qis/portfolio/reports/config.py

@@ -21,7 +21,8 @@ PERF_COLUMNS_RF0 = (PerfStat.TOTAL_RETURN,
                     PerfStat.SKEWNESS,
                     PerfStat.ALPHA_AN,
                     PerfStat.BETA,
-                    PerfStat.R2)
+                    PerfStat.R2,
+                    PerfStat.ALPHA_PVALUE)
 
 
 PERF_COLUMNS = (PerfStat.TOTAL_RETURN,
@@ -34,7 +35,8 @@ PERF_COLUMNS = (PerfStat.TOTAL_RETURN,
                 PerfStat.SKEWNESS,
                 PerfStat.ALPHA_AN,
                 PerfStat.BETA,
-                PerfStat.R2)
+                PerfStat.R2,
+                PerfStat.ALPHA_PVALUE)
 
 
 class ReportingFrequency(Enum):

{qis-3.1.4 → qis-3.1.6}/qis/settings.yaml

@@ -3,7 +3,6 @@
 # remove from git tracking:
 # git rm -r --cached setting.yaml
 
-
 RESOURCE_PATH:
   "..\\"
 
@@ -18,4 +17,3 @@ OUTPUT_PATH:
 
 AWS_POSTGRES:
   ""
-

{qis-3.1.4 → qis-3.1.6}/qis/utils/__init__.py

@@ -111,7 +111,7 @@ from qis.utils.df_ops import (
     get_first_nonnan_values,
     get_last_nonnan_values,
     get_last_nonnan,
-    merge_on_column,
+    merge_dfs_on_column,
     compute_nans_zeros_ratio_after_first_non_nan,
     reindex_upto_last_nonnan,
     multiply_df_by_dt,

{qis-3.1.4 → qis-3.1.6}/qis/utils/df_ops.py

@@ -549,19 +549,21 @@ def df12_merge_with_tz(df1: pd.DataFrame,
     return dfs
 
 
-def merge_on_column(df1: pd.DataFrame,
-                    df2: pd.DataFrame,
-                    is_drop_y: bool = True
-                    ) -> pd.DataFrame:
-    """
-    merge on homogeneous column with preservation of indices and drop dublicated, _y columns
-    """
-    joint_data = pd.merge(left=df1, right=df2,
-                          left_index=True, right_index=True,
-                          suffixes=('', '_y'), how='inner')
-    if is_drop_y:
-        unique_columns = sop.merge_lists_unique(list1=df1.columns.to_list(), list2=df2.columns.to_list())
-        joint_data = joint_data[unique_columns]
+def merge_dfs_on_column(data_df: pd.DataFrame,
+                        index_df: pd.DataFrame,
+                        index_column_in_data_df: str = 'bbg_ticker'
+                        ) -> pd.DataFrame:
+    """
+    merge data_df with index_df using index_column_in_data_df
+    index_df
+    """
+    data_df.index.name = 'index1'  # rename index
+    index_df.index.name = 'index2'  # rename index
+    # align dfs by index_column_in_data_df
+    index_df_joint_data = index_df.reindex(index=data_df[index_column_in_data_df].to_list())
+    # merge aligned dfs with reset index
+    joint_data = pd.concat([data_df.reset_index(drop=False), index_df_joint_data.reset_index(drop=False)], axis=1)
+    joint_data = joint_data.set_index(data_df.index.name)
     return joint_data
 
 
@@ -588,6 +590,7 @@ class UnitTests(Enum):
     SCORES = 2
     NONNANINDEX = 3
     REINDEX_UPTO_LAST_NONAN = 4
+    MERGE_DFS_ON_COLUMNS = 5
 
 
 def run_unit_test(unit_test: UnitTests):
@@ -643,10 +646,27 @@ def run_unit_test(unit_test: UnitTests):
         post_filled_up_nan = reindex_upto_last_nonnan(ds=ds, index=dates1, method='ffill')
         print(post_filled_up_nan)
 
+    elif unit_test == UnitTests.MERGE_DFS_ON_COLUMNS:
+        data_entries = {'Bond1': pd.Series(['AAA', 100.00, 'A3'], index=['bbg_ticker', 'face', 'raiting']),
+                        'Bond2': pd.Series(['AA', 100.00, 'A2'], index=['bbg_ticker', 'face', 'raiting']),
+                        'Bond3': pd.Series(['A', 100.00, 'A1'], index=['bbg_ticker', 'face', 'raiting']),
+                        'Bond4': pd.Series(['BBB', 100.00, 'B3'], index=['bbg_ticker', 'face', 'raiting'])}
+        data_df = pd.DataFrame.from_dict(data_entries, orient='index')
+
+        index_df = {'A': pd.Series([95.0], index=['price']),
+                    'AA': pd.Series([99.0], index=['price']),
+                    'AAA': pd.Series([101.0], index=['price']),
+                    'B': pd.Series([90.0], index=['price'])}
+        index_df = pd.DataFrame.from_dict(index_df, orient='index')
+        print(data_df)
+        print(index_df)
+        df = merge_dfs_on_column(data_df=data_df, index_df=index_df)
+        print(df)
+
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.REINDEX_UPTO_LAST_NONAN
+    unit_test = UnitTests.MERGE_DFS_ON_COLUMNS
 
     is_run_all_tests = False
     if is_run_all_tests:

{qis-3.1.4 → qis-3.1.6}/qis/utils/np_ops.py

@@ -620,7 +620,7 @@ def run_unit_test(unit_test: UnitTests):
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.CUM_POWER
+    unit_test = UnitTests.SHIFT_TEST
 
     is_run_all_tests = False
     if is_run_all_tests:

{qis-3.1.4 → qis-3.1.6}/qis/utils/ols.py

@@ -71,27 +71,30 @@ def estimate_ols_alpha_beta(x: Union[np.ndarray, pd.Series, pd.DataFrame],
                             y: Union[np.ndarray, pd.Series],
                             order: int = 1,
                             fit_intercept: bool = True
-                            ) -> Tuple[float, float, float]:
+                            ) -> Tuple[float, float, float, float]:
     try:
         reg_model = fit_ols(x=x, y=y, order=order, fit_intercept=fit_intercept)
     except:
         warnings.warn(f"problem with x={x}, y={y}")
-        return 0.0, 0.0, 0.0
+        return 0.0, 0.0, 0.0, 0.0
     if fit_intercept:
         if isinstance(reg_model.params, pd.Series):
             alpha = reg_model.params.iloc[0]
             beta = reg_model.params.iloc[1]
+            alpha_pvalue = reg_model.pvalues.iloc[0]
         else:
             alpha = reg_model.params[0]
             beta = reg_model.params[1]
+            alpha_pvalue = reg_model.pvalues[0]
     else:
         alpha = 0.0
+        alpha_pvalue = 0.0
         if isinstance(reg_model.params, pd.Series):
             beta = reg_model.params.iloc[0]
         else:
             beta = reg_model.params[0]
     r2 = reg_model.rsquared
-    return alpha, beta, r2
+    return alpha, beta, r2, alpha_pvalue
 
 
 def estimate_alpha_beta_paired_dfs(x: pd.DataFrame,
@@ -110,9 +113,9 @@ def estimate_alpha_beta_paired_dfs(x: pd.DataFrame,
     ncols = len(x.columns)
     alphas, betas = np.zeros(ncols), np.zeros(ncols)
     for idx in np.arange(ncols):
-        alphas[idx], betas[idx], _ = estimate_ols_alpha_beta(x=x_np[:, idx],
-                                                             y=y_np[:, idx],
-                                                             fit_intercept=fit_intercept)
+        alphas[idx], betas[idx], _, _ = estimate_ols_alpha_beta(x=x_np[:, idx],
+                                                                y=y_np[:, idx],
+                                                                fit_intercept=fit_intercept)
     alphas = pd.Series(alphas, index=x.columns)
     betas = pd.Series(betas, index=x.columns)
     return alphas, betas