qis 3.2.1__tar.gz → 3.2.3__tar.gz

{qis-3.2.1 → qis-3.2.3}/PKG-INFO

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

{qis-3.2.1 → qis-3.2.3}/pyproject.toml

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

{qis-3.2.1 → qis-3.2.3}/qis/models/__init__.py

@@ -41,6 +41,7 @@ from qis.models.linear.ewm import (
     compute_ewm_sharpe_from_prices,
     compute_ewm_std1_norm,
     compute_ewm_vol,
+    compute_ewm_newey_west_vol,
     compute_ewm_xy_beta_tensor,
     compute_one_factor_ewm_betas,
     compute_roll_mean,
@@ -55,8 +56,8 @@ from qis.models.linear.ewm_factors import (LinearModel,
                                            EwmLinearModel,
                                            compute_portfolio_benchmark_betas,
                                            compute_portfolio_benchmark_beta_alpha_attribution,
-                                           compute_benchmarks_beta_attribution
-                                           )
+                                           compute_benchmarks_beta_attribution,
+                                           estimate_linear_model)
 
 from qis.models.linear.pca import(
     compute_eigen_portfolio_weights,

{qis-3.2.1 → qis-3.2.3}/qis/models/linear/ewm.py

@@ -664,7 +664,7 @@ def compute_ewm_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
 
 
 def compute_ewm_newey_west_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
-                               num_lags: int = 3,
+                               num_lags: int = 2,
                                span: Optional[Union[float, np.ndarray]] = None,
                                ewm_lambda: Union[float, np.ndarray] = 0.94,
                                mean_adj_type: MeanAdjType = MeanAdjType.NONE,
@@ -675,7 +675,8 @@ def compute_ewm_newey_west_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
                                annualization_factor: Optional[float] = None,
                                warmup_period: Optional[int] = None,
                                nan_backfill: NanBackfill = NanBackfill.FFILL
-                               ) -> Union[pd.DataFrame, pd.Series, np.ndarray]:
+                               ) -> Tuple[Union[pd.DataFrame, pd.Series, np.ndarray],
+                                          Union[pd.DataFrame, pd.Series, np.ndarray]]:
     """
     implementation of newey west vol estimator
     implementation of ewm recursion for variance/volatility computation
@@ -694,7 +695,6 @@ def compute_ewm_newey_west_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
                                      nan_backfill=nan_backfill)
 
     # initial conditions
-    a = a
     if init_value is None:
         init_value = set_init_dim1(data=a, init_type=init_type)
 
@@ -703,18 +703,40 @@ def compute_ewm_newey_west_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
         if isinstance(init_value, np.ndarray):
             init_value = float(init_value)
 
-    ewm = ewm_recursion(a=np.square(a), ewm_lambda=ewm_lambda, init_value=init_value, nan_backfill=nan_backfill)
+    if span is not None:
+        ewm_lambda = 1.0 - 2.0 / (span + 1.0)
+    ewm_lambda_1 = 1.0 - ewm_lambda
+
+    def matrix_recursion(a_m: np.ndarray) -> np.ndarray:
+        t = a.shape[0]
+        last_covar = np.zeros((a.shape[1], a.shape[1]))
+        ewm_m = np.zeros_like(a_m)
+        for idx in range(0, t):
+            r_ij = np.outer(a[idx], a_m[idx])
+            covar = ewm_lambda_1 * r_ij + ewm_lambda * last_covar
+            fill_value = last_covar
+            last_covar = np.where(np.isfinite(covar), covar, fill_value)
+            ewm_m[idx, :] = np.diag(last_covar) + np.diag(np.transpose(last_covar))
+        return ewm_m
 
+    ewm0 = ewm_recursion(a=np.square(a), ewm_lambda=ewm_lambda, init_value=init_value, nan_backfill=nan_backfill)
+    nw_adjustment = np.zeros_like(ewm0)
     # compute m recursions
-    for m in np.arange(1, num_lags):
+    for m in np.arange(1, num_lags+1):
         # lagged value
         a_m = np.empty_like(a)
         a_m[m:] = a[:-m]
         a_m[:m] = np.nan
-        ewm_m = ewm_recursion(a=a*a_m, ewm_lambda=ewm_lambda, init_value=init_value, nan_backfill=nan_backfill)
-        ewm += (1.0-m/(num_lags+1))*ewm_m
+        # qqq
+        ewm_m = matrix_recursion(a_m=a_m)
+        nw_adjustment += (1.0-m/(num_lags+1))*ewm_m
+
+    ewm_nw = ewm0 + nw_adjustment
+    nw_ratio = np.divide(ewm_nw, ewm0, where=ewm0 > 0.0)
+
     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)
+        ewm_nw = npo.set_nans_for_warmup_period(a=ewm_nw, warmup_period=warmup_period)
+        nw_ratio = npo.set_nans_for_warmup_period(a=nw_ratio, warmup_period=warmup_period)
 
     if annualize or annualization_factor is not None:
         if annualization_factor is None:
@@ -723,16 +745,18 @@ def compute_ewm_newey_west_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
             else:
                 warnings.warn(f"in compute_ewm  annualization_factor for np array default is 1")
                 annualization_factor = 1.0
-        ewm = annualization_factor * ewm
+        ewm_nw = annualization_factor * ewm_nw
 
     if apply_sqrt:
-        ewm = np.sqrt(ewm)
+        ewm_nw = np.sqrt(ewm_nw)
 
     if isinstance(data, pd.DataFrame):
-        ewm = pd.DataFrame(data=ewm, index=data.index, columns=data.columns)
+        ewm_nw = pd.DataFrame(data=ewm_nw, index=data.index, columns=data.columns)
+        nw_ratio = pd.DataFrame(data=nw_ratio, index=data.index, columns=data.columns)
     elif isinstance(data, pd.Series):
-        ewm = pd.Series(data=ewm, index=data.index, name=data.name)
-    return ewm
+        ewm_nw = pd.Series(data=ewm_nw, index=data.index, name=data.name)
+        nw_ratio = pd.Series(data=nw_ratio, index=data.index, name=data.name)
+    return ewm_nw, nw_ratio
 
 
 def compute_roll_mean(data: Union[pd.DataFrame, pd.Series, np.ndarray],

{qis-3.2.1 → qis-3.2.3}/qis/models/linear/ewm_factors.py

@@ -10,6 +10,7 @@ from typing import Dict, Optional, Tuple, Literal
 from enum import Enum
 
 # qis
+import qis as qis
 import qis.utils.df_ops as dfo
 import qis.perfstats.returns as ret
 import qis.plots.time_series as pts
@@ -51,7 +52,10 @@ class LinearModel:
         factor_exposures = pd.DataFrame.from_dict(factor_exposures)
         return factor_exposures
 
-    def get_asset_factor_betas(self, asset: str = None) -> pd.DataFrame:
+    def get_asset_factor_betas(self,
+                               time_period: TimePeriod = None,
+                               asset: str = None
+                               ) -> pd.DataFrame:
         """
         return df of asset exposures to factors
         """
@@ -61,6 +65,8 @@ class LinearModel:
         for factor, factor_exp in self.loadings.items():
             exps[factor] = factor_exp[asset]
         exps = pd.DataFrame.from_dict(exps)
+        if time_period is not None:
+            exps = time_period.locate(exps)
         return exps
 
     def get_asset_factor_attribution(self, asset: str = None, add_total: bool = True) -> pd.DataFrame:
@@ -247,6 +253,18 @@ def compute_benchmarks_beta_attribution(portfolio_nav: pd.Series,
     return joint_attrib
 
 
+def estimate_linear_model(price: pd.Series, hedges: pd.DataFrame,
+                          freq: str = 'W-WED',
+                          span: int = 26,
+                          mean_adj_type: MeanAdjType = MeanAdjType.NONE
+                          ) -> EwmLinearModel:
+    y = qis.to_returns(price.to_frame(), freq=freq, is_log_returns=True, drop_first=True)
+    x = qis.to_returns(hedges, freq=freq, is_log_returns=True, drop_first=True)
+    ewm_linear_model = EwmLinearModel(x=x.reindex(index=y.index), y=y)
+    ewm_linear_model.fit(span=span, is_x_correlated=True, mean_adj_type=mean_adj_type)
+    return ewm_linear_model
+
+
 class UnitTests(Enum):
     MODEL = 1
     ATTRIBUTION = 2
@@ -313,3 +331,5 @@ if __name__ == '__main__':
             run_unit_test(unit_test=unit_test)
     else:
         run_unit_test(unit_test=unit_test)
+
+

{qis-3.2.1 → qis-3.2.3}/qis/plots/derived/perf_table.py

@@ -4,8 +4,6 @@ import pandas as pd
 import matplotlib.pyplot as plt
 from typing import List, Tuple, Callable, Optional, Dict, Union
 from enum import Enum
-
-import qis
 # qis
 import qis.utils.dates as da
 import qis.utils.df_str as dfs
@@ -106,7 +104,7 @@ def get_ra_perf_benchmark_columns(prices: pd.DataFrame,
             df[perf_column.to_str(**kwargs)] = dfs.series_to_str(ds=ra_perf_table[perf_column.to_str()],
                                                                  var_format=perf_column.to_format(**kwargs))
         else:
-            df[perf_column.to_str(**kwargs)] = ra_perf_table[perf_column.to_str()]
+            df[perf_column.to_str()] = ra_perf_table[perf_column.to_str()]
 
     if drop_benchmark:
         df = df.drop(benchmark, axis=0)

{qis-3.2.1 → qis-3.2.3}/qis/portfolio/multi_portfolio_data.py

@@ -649,7 +649,8 @@ class MultiPortfolioData:
                       ax: plt.Subplot = None,
                       **kwargs) -> None:
         
-        turnover = self.get_turnover(turnover_rolling_period=turnover_rolling_period, freq_turnover=freq_turnover,
+        turnover = self.get_turnover(turnover_rolling_period=turnover_rolling_period,
+                                     freq_turnover=freq_turnover,
                                      is_unit_based_traded_volume=is_unit_based_traded_volume,
                                      time_period=time_period)
         freq = pd.infer_freq(turnover.index)

{qis-3.2.1 → qis-3.2.3}/qis/portfolio/portfolio_data.py

@@ -339,6 +339,8 @@ class PortfolioData:
     def get_turnover(self,
                      is_agg: bool = False,
                      is_grouped: bool = False,
+                     group_data: pd.Series = None,
+                     group_order: List[str] = None,
                      time_period: TimePeriod = None,
                      roll_period: Optional[int] = 260,
                      is_vol_adjusted: bool = False,
@@ -366,11 +368,15 @@ class PortfolioData:
             turnover = pd.Series(np.nansum(turnover, axis=1), index=turnover.index, name=self.nav.name)
             turnover = turnover.reindex(index=self.nav.index)
         elif is_grouped:  # agg by groups
+            if group_data is None:
+                group_data = self.group_data
+            if group_order is None:
+                group_order = self.group_order
             turnover = dfg.agg_df_by_groups_ax1(df=turnover,
-                                                group_data=self.group_data,
+                                                group_data=group_data,
                                                 agg_func=np.nansum,
                                                 total_column=str(self.nav.name) if add_total else None,
-                                                group_order=self.group_order)
+                                                group_order=group_order)
         else:
             if add_total:
                 turnover = pd.concat([turnover.sum(axis=1).rename(self.nav.name), turnover], axis=1)
@@ -1495,6 +1501,13 @@ class StrategySignalData:
                 data_dict[key] = time_period.locate(df)
         return StrategySignalData(**data_dict)
 
+    def rename_data(self, names_map: Dict[str, str]) -> StrategySignalData:
+        data_dict = asdict(self)
+        for key, df in data_dict.items():
+            if df is not None:
+                data_dict[key] = df.rename(names_map, axis=1)
+        return StrategySignalData(**data_dict)
+
     def get_current_signal_by_groups(self, group_data: pd.Series,
                                      group_order: List[str] = None
                                      ) -> Dict[str, pd.DataFrame]:

{qis-3.2.1 → qis-3.2.3}/qis/portfolio/reports/multi_assets_factsheet.py

@@ -47,8 +47,13 @@ class MultiAssetsReport:
         self.perf_params = perf_params
         self.regime_params = regime_params
 
-    def get_prices(self, benchmark: str = None, time_period: TimePeriod = None) -> pd.DataFrame:
-        if benchmark is not None and benchmark not in self.prices.columns:
+    def get_prices(self,
+                   benchmark: str = None,
+                   add_benchmarks_to_navs: bool = False,
+                   time_period: TimePeriod = None) -> pd.DataFrame:
+        if add_benchmarks_to_navs:
+            prices = pd.concat([self.benchmark_prices, self.prices], axis=1)
+        elif benchmark is not None and benchmark not in self.prices.columns:
             if isinstance(self.benchmark_prices, pd.Series):
                 prices = pd.concat([self.benchmark_prices, self.prices], axis=1)
             else:
@@ -82,6 +87,7 @@ class MultiAssetsReport:
 
     def plot_ra_perf_table(self,
                            benchmark: str,
+                           add_benchmarks_to_navs: bool = False,
                            time_period: TimePeriod = None,
                            perf_columns: List[PerfStat] = qis.BENCHMARK_TABLE_COLUMNS,
                            perf_params: PerfParams = None,
@@ -89,8 +95,10 @@ class MultiAssetsReport:
                            ax: plt.Subplot = None,
                            **kwargs
                            ) -> None:
-        prices = self.get_prices(benchmark, time_period=time_period)
-        title = title or f"RA performance table for {self.perf_params.freq_vol}-freq returns with beta to {benchmark}: {qis.get_time_period(prices).to_str()}"
+        prices = self.get_prices(benchmark=benchmark, add_benchmarks_to_navs=add_benchmarks_to_navs,
+                                 time_period=time_period)
+        title = title or f"RA performance table for {self.perf_params.freq_vol}-freq returns with" \
+                         f" beta to {benchmark}: {qis.get_time_period(prices).to_str()}"
         #if len(prices.columns) >= 12:
         #    local_kwargs = qis.update_kwargs(kwargs, dict(fontsize=3, pad=10, bbox=(0, -0.4, 1.0, 1.6)))
         #else:
@@ -153,7 +161,8 @@ class MultiAssetsReport:
                  perf_params: PerfParams = None,
                  ax: plt.Subplot = None,
                  **kwargs) -> None:
-        prices = self.get_prices(time_period=time_period, benchmark=regime_benchmark)
+        prices = self.get_prices(time_period=time_period, benchmark=regime_benchmark,
+                                 add_benchmarks_to_navs=add_benchmarks_to_navs)
         prices0 = prices
         if not add_benchmarks_to_navs and regime_benchmark in prices.columns:
             prices0 = prices0.drop(regime_benchmark, axis=1)
@@ -194,6 +203,7 @@ class MultiAssetsReport:
         self.add_regime_shadows(ax=ax, regime_benchmark=regime_benchmark, data_df=prices)
 
     def plot_annual_returns(self,
+                            add_benchmarks_to_navs: bool = False,
                             heatmap_freq: str = 'YE',
                             date_format: str = '%Y',
                             time_period: TimePeriod = None,
@@ -205,7 +215,8 @@ class MultiAssetsReport:
                                         new_kwargs=dict(fontsize=table_fontsize,
                                                         square=False,
                                                         x_rotation=90))
-        qis.plot_periodic_returns_table(prices=self.get_prices(time_period=time_period),
+        qis.plot_periodic_returns_table(prices=self.get_prices(time_period=time_period,
+                                                               add_benchmarks_to_navs=add_benchmarks_to_navs),
                                         freq=heatmap_freq,
                                         ax=ax,
                                         title=title or f"{heatmap_freq} Returns",
@@ -214,11 +225,12 @@ class MultiAssetsReport:
 
     def plot_corr_table(self,
                         corr_freq: str = 'W-WED',
+                        add_benchmarks_to_navs: bool = True,
                         time_period: TimePeriod = None,
                         ax: plt.Subplot = None,
                         **kwargs
                         ) -> None:
-        prices = self.get_prices(time_period=time_period)
+        prices = self.get_prices(time_period=time_period, add_benchmarks_to_navs=add_benchmarks_to_navs)
         if len(prices.columns) == 1:  # cannot compute corr
             return
         if len(prices.columns) >= 12:
@@ -381,11 +393,12 @@ class MultiAssetsReport:
                               time_period: TimePeriod = None,
                               benchmark: Optional[str] = None,
                               perf_column: PerfStat = PerfStat.SHARPE_RF0,
+                              add_benchmarks_to_navs: bool = True,
                               title: str = None,
                               ax: plt.Subplot = None,
                               **kwargs
                               ) -> None:
-        prices = self.get_prices(benchmark=benchmark, time_period=time_period)
+        prices = self.get_prices(benchmark=benchmark, add_benchmarks_to_navs=add_benchmarks_to_navs, time_period=time_period)
         qis.plot_ra_perf_bars(prices=prices,
                               benchmark=benchmark,
                               perf_column=perf_column,
@@ -406,6 +419,8 @@ def generate_multi_asset_factsheet(prices: pd.DataFrame,
                                    figsize: Tuple[float, float] = (8.3, 11.7),  # A4 for portrait
                                    fontsize: int = 3,
                                    factsheet_name: str = None,
+                                   performance_bars: Tuple[PerfStat, PerfStat] = (PerfStat.SHARPE_RF0, PerfStat.MAX_DD),
+                                   drop_1y_ra_perf_table: bool = True,
                                    **kwargs
                                    ) -> plt.Figure:
     # use passed benchmark
@@ -490,16 +505,22 @@ def generate_multi_asset_factsheet(prices: pd.DataFrame,
                                             **kwargs)
 
     report.plot_performance_bars(ax=fig.add_subplot(gs[0:2, 2]),
-                                 perf_column=PerfStat.SHARPE_RF0, **kwargs)
+                                 add_benchmarks_to_navs=add_benchmarks_to_navs,
+                                 benchmark=benchmark,
+                                 perf_column=performance_bars[0], **kwargs)
     report.plot_performance_bars(ax=fig.add_subplot(gs[0:2, 3]),
-                                 perf_column=PerfStat.MAX_DD, **kwargs)
+                                 add_benchmarks_to_navs=add_benchmarks_to_navs,
+                                 benchmark=benchmark,
+                                 perf_column=performance_bars[1], **kwargs)
 
-    if len(prices.columns) >= 8:
+    if drop_1y_ra_perf_table or len(prices.columns) >= 8:
         report.plot_ra_perf_table(benchmark=benchmark,
+                                  add_benchmarks_to_navs=add_benchmarks_to_navs,
                                   ax=fig.add_subplot(gs[2:4, 2:]),
                                   **kwargs)
     else:  # plot two tables
         report.plot_ra_perf_table(benchmark=benchmark,
+                                  add_benchmarks_to_navs=add_benchmarks_to_navs,
                                   ax=fig.add_subplot(gs[2, 2:]),
                                   **kwargs)
 
@@ -513,14 +534,17 @@ def generate_multi_asset_factsheet(prices: pd.DataFrame,
                                   **local_kwargs)
 
     report.plot_annual_returns(ax=fig.add_subplot(gs[4:6, 2:]),
+                               add_benchmarks_to_navs=add_benchmarks_to_navs,
                                heatmap_freq=heatmap_freq,
                                **kwargs)
 
     report.plot_corr_table(freq=perf_params.freq,
+                           add_benchmarks_to_navs=add_benchmarks_to_navs,
                            ax=fig.add_subplot(gs[6:8, 2]),
                            **kwargs)
     report.plot_corr_table(freq=perf_params.freq,
                            ax=fig.add_subplot(gs[6:8, 3]),
+                           add_benchmarks_to_navs=add_benchmarks_to_navs,
                            **qis.update_kwargs(kwargs, dict(time_period=time_period1)))
 
     report.plot_regime_data(benchmark=benchmark,

{qis-3.2.1 → qis-3.2.3}/qis/portfolio/reports/multi_strategy_factseet_pybloqs.py

@@ -82,22 +82,22 @@ def generate_multi_portfolio_factsheet_with_pyblogs(multi_portfolio_data: MultiP
         b_ra_perf_table = p.Block([p.Paragraph(f"Risk-adjusted Performance table for {key}", **KWARGS_TITLE),
                                     p.Block(table,
                                             formatters=[
-                                                tf.FmtPercent(n_decimals=2, columns=[PerfStat.TOTAL_RETURN.to_str(**kwargs),
-                                                                                     PerfStat.PA_RETURN.to_str(**kwargs),
-                                                                                     PerfStat.VOL.to_str(**kwargs),
-                                                                                     PerfStat.MAX_DD.to_str(**kwargs),
-                                                                                     PerfStat.ALPHA_AN.to_str(**kwargs),
-                                                                                     PerfStat.R2.to_str(**kwargs)
+                                                tf.FmtPercent(n_decimals=2, columns=[PerfStat.TOTAL_RETURN.to_str(),
+                                                                                     PerfStat.PA_RETURN.to_str(),
+                                                                                     PerfStat.VOL.to_str(),
+                                                                                     PerfStat.MAX_DD.to_str(),
+                                                                                     PerfStat.ALPHA_AN.to_str(),
+                                                                                     PerfStat.R2.to_str()
                                                                                      ], apply_to_header_and_index=False),
                                                 fmt_highlight_base,
                                                 fmt_highlight_index,
                                                 tf.FmtReplaceNaN(value=''),
-                                                tf.FmtHeatmap(columns=[PerfStat.PA_RETURN.to_str(**kwargs),
-                                                                       PerfStat.SHARPE_EXCESS.to_str(**kwargs),
-                                                                       PerfStat.ALPHA_AN.to_str(**kwargs),
-                                                                       PerfStat.BETA.to_str(**kwargs)]),
-                                                tf.FmtHeatmap(columns=[PerfStat.MAX_DD.to_str(**kwargs),
-                                                                       PerfStat.SKEWNESS.to_str(**kwargs)], max_color=(255,0,255)),
+                                                tf.FmtHeatmap(columns=[PerfStat.PA_RETURN.to_str(),
+                                                                       PerfStat.SHARPE_EXCESS.to_str(),
+                                                                       PerfStat.ALPHA_AN.to_str(),
+                                                                       PerfStat.BETA.to_str()]),
+                                                tf.FmtHeatmap(columns=[PerfStat.MAX_DD.to_str(),
+                                                                       PerfStat.SKEWNESS.to_str()], max_color=(255,0,255)),
                                                 tf.FmtAddCellBorder(each=1.0,
                                                                     columns=ra_perf_table.columns.to_list()[:1],
                                                                     color=tf.colors.GREY,
@@ -114,7 +114,7 @@ def generate_multi_portfolio_factsheet_with_pyblogs(multi_portfolio_data: MultiP
     fig_size = qis.get_df_table_size(df=ra_perf_table)
     fig_perf_bar, axs = plt.subplots(1, len(perf_columns), figsize=(12, 1.2*fig_size[1]), constrained_layout=True)
     for idx, perf_column in enumerate(perf_columns):
-        df = ra_perf_table[perf_column.to_str(**kwargs)].to_frame()
+        df = ra_perf_table[perf_column.to_str()].to_frame()
         colors = qis.compute_heatmap_colors(a=df.to_numpy())
         qis.plot_vbars(df=df,
                        var_format=perf_column.to_format(**kwargs),
@@ -132,7 +132,8 @@ def generate_multi_portfolio_factsheet_with_pyblogs(multi_portfolio_data: MultiP
 
     # 3. regime conditional
     fig_size = qis.get_df_table_size(df=ra_perf_table)
-    fig_perf_regime, axs = plt.subplots(1, len(multi_portfolio_data.benchmark_prices.columns), figsize=(12, 1.2*fig_size[1]), constrained_layout=True)
+    fig_perf_regime, axs = plt.subplots(1, len(multi_portfolio_data.benchmark_prices.columns),
+                                        figsize=(12, 1.2*fig_size[1]), constrained_layout=True)
     if len(multi_portfolio_data.benchmark_prices.columns) == 1:
         axs = [axs]
     for idx, benchmark in enumerate(multi_portfolio_data.benchmark_prices.columns):
@@ -195,7 +196,7 @@ def generate_multi_portfolio_factsheet_with_pyblogs(multi_portfolio_data: MultiP
         x_limits = (np.nanmin(xy[param_name]), np.nanmax(xy[param_name]))
 
         fig_scatter1, ax = plt.subplots(1, 1, figsize=(14, 4.5), constrained_layout=True)
-        qis.plot_scatter(df=xy, x=param_name, y=PerfStat.SHARPE_EXCESS.to_str(**kwargs), hue=hue_name,
+        qis.plot_scatter(df=xy, x=param_name, y=PerfStat.SHARPE_EXCESS.to_str(), hue=hue_name,
                          title=f"Sharpe",
                          var_format='{:.2f}',
                          x_limits=x_limits,
@@ -207,7 +208,7 @@ def generate_multi_portfolio_factsheet_with_pyblogs(multi_portfolio_data: MultiP
         blocks.append(b_fig_scatter1)
 
         fig_scatter2, ax = plt.subplots(1, 1, figsize=(14, 4.5), constrained_layout=True)
-        qis.plot_scatter(df=xy, x=param_name, y=PerfStat.MAX_DD.to_str(**kwargs), hue=hue_name,
+        qis.plot_scatter(df=xy, x=param_name, y=PerfStat.MAX_DD.to_str(), hue=hue_name,
                          title=f"Max DD",
                          var_format='{:.2%}',
                          x_limits=x_limits,

{qis-3.2.1 → qis-3.2.3}/qis/portfolio/reports/strategy_benchmark_factsheet.py

@@ -507,6 +507,8 @@ def weights_tracking_error_report_by_ac_subac(multi_portfolio_data: MultiPortfol
                                               ac_group_order: List[str] = None,
                                               sub_ac_group_data: pd.Series = None,
                                               sub_ac_group_order: List[str] = None,
+                                              turnover_groups: pd.Series = None,
+                                              turnover_order: List[str] = None,
                                               time_period: TimePeriod = None,
                                               perf_params: PerfParams = PERF_PARAMS,
                                               regime_params: BenchmarkReturnsQuantileRegimeSpecs = REGIME_PARAMS,

{qis-3.2.1 → qis-3.2.3}/qis/portfolio/reports/strategy_factsheet.py

@@ -40,8 +40,8 @@ def generate_strategy_factsheet(portfolio_data: PortfolioData,
                                 fontsize: int = 4,
                                 weight_change_sample_size: int = 20,
                                 weight_report_time_period: TimePeriod = None,
-                                add_current_position_var_risk_sheet: bool = True,
-                                add_weights_turnover_sheet: bool = True,
+                                add_current_position_var_risk_sheet: bool = False,
+                                add_weights_turnover_sheet: bool = False,
                                 add_grouped_exposures: bool = False,
                                 add_grouped_cum_pnl: bool = False,
                                 add_weight_change_report: bool = False,
@@ -608,8 +608,7 @@ def generate_strategy_factsheet(portfolio_data: PortfolioData,
 
         fig = qis.generate_price_history_report(prices=portfolio_data.prices,
                                                 **qis.update_kwargs(kwargs, dict(fontsize=4, figsize=figsize,
-                                                                                 perf_columns=perf_columns,
-                                                                                 df_to_add=df_to_add)))
+                                                                                 perf_columns=perf_columns)))
         fig.suptitle('Program Instrument Universe', fontweight="bold", fontsize=8, color='blue')
         figs.append(fig)