qis 3.1.3__tar.gz → 3.1.5__tar.gz

{qis-3.1.3 → qis-3.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qis
-Version: 3.1.3
+Version: 3.1.5
 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.3 → qis-3.1.5}/pyproject.toml

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

{qis-3.1.3 → qis-3.1.5}/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.3 → qis-3.1.5}/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.3 → qis-3.1.5}/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.3 → qis-3.1.5}/qis/plots/bars.py

@@ -217,7 +217,7 @@ def plot_bars(df: Union[pd.DataFrame, pd.Series],
     return fig
 
 
-def plot_vbars(df: pd.DataFrame,
+def plot_vbars(df: Union[pd.DataFrame, pd.Series],
                title: Optional[str] = None,
                fontsize: int = 10,
                add_bar_values: bool = True,
@@ -244,6 +244,8 @@ def plot_vbars(df: pd.DataFrame,
                **kwargs
                ) -> plt.Figure:
 
+    if isinstance(df, pd.Series):
+        df = df.to_frame()
     category_names = df.columns.to_list()
 
     if add_total_to_index and totals is not None:
@@ -516,7 +518,7 @@ def run_unit_test(unit_test: UnitTests):
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.BARS
+    unit_test = UnitTests.VBAR_WEIGHTS
 
     is_run_all_tests = False
     if is_run_all_tests:

{qis-3.1.3 → qis-3.1.5}/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.3 → qis-3.1.5}/qis/plots/table.py

@@ -49,6 +49,7 @@ def plot_df_table(df: pd.DataFrame,
                   data_colors: List[Tuple[float, float, float]] = None,
                   diagonal_color: str = None,
                   rows_edge_lines: List[int] = None,
+                  rows_edge_color: str = 'blue',
                   columns_edge_lines: List[Tuple[int, str]] = None,
                   bold_font: bool = False,
                   linewidth: float = 0.5,  # table borders
@@ -211,7 +212,7 @@ def plot_df_table(df: pd.DataFrame,
 
     if rows_edge_lines is not None:
         for rows_edge_line in rows_edge_lines:
-            ax.axhline(y=rows_edge_line, color='black', alpha=0.5*alpha, lw=0.75)
+            ax.axhline(y=rows_edge_line, color=rows_edge_color, alpha=0.5*alpha, lw=0.75)
 
     if columns_edge_lines is not None:
         for columns_edge_line in columns_edge_lines:

{qis-3.1.3 → qis-3.1.5}/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.3 → qis-3.1.5}/qis/portfolio/portfolio_data.py

@@ -80,6 +80,7 @@ class PortfolioData:
     benchmark_prices: pd.DataFrame = None  # can pass benchmark prices here
     ticker: str = None
     strategy_signal_data: StrategySignalData = None
+    covar_dict: Dict[pd.Timestamp, pd.DataFrame] = None  # for computing risk contributions
 
     def __post_init__(self):
         if isinstance(self.nav, pd.DataFrame):
@@ -214,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
         """
@@ -222,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:
@@ -715,7 +721,7 @@ class PortfolioData:
         return portfolio_vars, instrument_vars
 
     def compute_risk_contributions_implied_by_covar(self,
-                                                    covar_dict: Dict[pd.Timestamp, pd.DataFrame],
+                                                    covar_dict: Dict[pd.Timestamp, pd.DataFrame] = None,
                                                     group_data: pd.Series = None,
                                                     group_order: List[str] = None,
                                                     align_with_covar_dates: bool = True,
@@ -725,6 +731,11 @@ class PortfolioData:
         """
         compute risk contributions using covar_dict
         """
+        if covar_dict is None:
+            if self.covar_dict is None:
+                raise ValueError(f"must provide covar_dict")
+            else:
+                covar_dict = self.covar_dict
         strategy_weights = self.get_weights(freq=freq, is_input_weights=True)
         covar_index = list(covar_dict.keys())
         strategy_rc = {}
@@ -1236,10 +1247,13 @@ class PortfolioData:
                              add_top_bar_values: Optional[bool] = None,
                              time_period: TimePeriod = None,
                              title: str = None,
+                             group_data: pd.Series = None,
+                             group_order: List[str] = None,
                              ax: plt.Subplot = None,
                              **kwargs
                              ) -> None:
-        weights = self.get_weights(is_input_weights=True, freq=None, is_grouped=is_grouped)
+        weights = self.get_weights(is_input_weights=True, freq=None, is_grouped=is_grouped,
+                                   group_data=group_data, group_order=group_order)
         if time_period is not None:
             weights_1 = time_period.locate(weights)
             if len(weights_1.index) > 0:
@@ -1456,6 +1470,7 @@ class PortfolioData:
                        ax=axs[1],
                        **kwargs)
 
+
 @dataclass
 class StrategySignalData:
     """

{qis-3.1.3 → qis-3.1.5}/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.3 → qis-3.1.5}/qis/portfolio/reports/strategy_benchmark_factsheet.py

@@ -566,9 +566,9 @@ def weights_tracking_error_report_by_ac_subac(multi_portfolio_data: MultiPortfol
         # benchmark weights
         benchmark_data = multi_portfolio_data.portfolio_datas[benchmark_idx]
         benchmark_ticker = benchmark_data.ticker
-        benchmark_exposures_ac = benchmark_data.get_weights(group_data=ac_group_data, group_order=sub_ac_group_order,
+        benchmark_exposures_ac = benchmark_data.get_weights(group_data=ac_group_data, group_order=ac_group_order,
                                                             **weight_kwargs)
-        benchmark_exposures_subac = benchmark_data.get_weights(group_data=sub_ac_group_data, group_order=ac_group_order,
+        benchmark_exposures_subac = benchmark_data.get_weights(group_data=sub_ac_group_data, group_order=sub_ac_group_order,
                                                                **weight_kwargs)
 
         # plot strategy and benchmark weights by ac

{qis-3.1.3 → qis-3.1.5}/qis/settings.yaml

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

{qis-3.1.3 → qis-3.1.5}/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