qis 3.0.4__tar.gz → 3.0.6__tar.gz

{qis-3.0.4 → qis-3.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qis
-Version: 3.0.4
+Version: 3.0.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.0.4 → qis-3.0.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "qis"
-version = "3.0.4"
+version = "3.0.6"
 description = "Implementation of visualisation and reporting analytics for Quantitative Investment Strategies"
 license = "LICENSE.txt"
 authors = ["Artur Sepp <artursepp@gmail.com>"]
@@ -51,5 +51,6 @@ fsspec = ">=2022.11.0"
 yfinance = ">=0.1.38"
 
 [build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
+requires = ["poetry-core>=1.0.0", "hatchling==1.27.0", "hatch-vcs"]
+#build-backend = "hatchling.build"
+build-backend = "poetry.core.masonry.api"

{qis-3.0.4 → qis-3.0.6}/qis/examples/factsheets/strategy_benchmark.py

@@ -17,7 +17,8 @@ from qis.portfolio.reports.config import fetch_default_report_kwargs
 from qis.portfolio.reports.strategy_benchmark_factsheet import (generate_strategy_benchmark_factsheet_plt,
                                                                 generate_strategy_benchmark_active_perf_plt,
                                                                 generate_performance_attribution_report,
-                                                                weights_tracking_error_report)
+                                                                weights_tracking_error_report,
+                                                                weights_tracking_error_report_cross)
 
 
 def fetch_universe_data() -> Tuple[pd.DataFrame, pd.DataFrame, pd.Series]:
@@ -79,6 +80,7 @@ class UnitTests(Enum):
     PERFORMANCE_ATTRIBUTION = 2
     ACTIVE_PERFORMANCE = 3
     TRACKING_ERROR = 4
+    TRACKING_ERROR_CROSS = 5
 
 
 @qis.timer
@@ -140,12 +142,23 @@ def run_unit_test(unit_test: UnitTests):
         weights_tracking_error_report(multi_portfolio_data=multi_portfolio_data,
                                       time_period=time_period)
 
+    elif unit_test == UnitTests.TRACKING_ERROR_CROSS:
+        # compute pd_covras
+        covar_dict = qis.estimate_rolling_ewma_covar(prices=prices,
+                                                    time_period=time_period,
+                                                    returns_freq='W-WED',
+                                                    rebalancing_freq='ME',
+                                                    span=52)
+        multi_portfolio_data.covar_dict = covar_dict
+        weights_tracking_error_report_cross(multi_portfolio_data=multi_portfolio_data,
+                                            time_period=time_period)
+
     plt.show()
 
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.TRACKING_ERROR
+    unit_test = UnitTests.TRACKING_ERROR_CROSS
 
     is_run_all_tests = False
     if is_run_all_tests:

{qis-3.0.4 → qis-3.0.6}/qis/file_utils.py

@@ -231,17 +231,21 @@ def save_df_to_excel(data: Union[pd.DataFrame, List[pd.DataFrame], Dict[str, pd.
         if sheet_names is None:
             sheet_names = [f"Sheet {n+1}" for n, _ in enumerate(data)]
         for df, name in zip(data, sheet_names):
-            df = delocalize_df(df)
-            if transpose:
-                df = df.T
-            df.to_excel(excel_writer=excel_writer, sheet_name=name)
+            if df is not None:
+                df = delocalize_df(df)
+                if transpose:
+                    df = df.T
+                df.to_excel(excel_writer=excel_writer, sheet_name=name)
     elif isinstance(data, dict):  # publish with sheet names
         for key, df in data.items():
-            df = delocalize_df(df)
-            if transpose:
-                df = df.T
-            df.to_excel(excel_writer=excel_writer, sheet_name=key)
+            if df is not None:
+                df = delocalize_df(df)
+                if transpose:
+                    df = df.T
+                df.to_excel(excel_writer=excel_writer, sheet_name=key)
     else:
+        if data is None:
+            raise ValueError(f"None data")
         if transpose:
             data = data.T
         data = delocalize_df(data)

{qis-3.0.4 → qis-3.0.6}/qis/plots/boxplot.py

@@ -552,6 +552,7 @@ def run_unit_test(unit_test: UnitTests):
                               hue_var_name='instruments',
                               y_var_name='weights',
                               ylabel='weights',
+                              legend_loc=None,
                               showmedians=True,
                               add_y_median_labels=True)
 

{qis-3.0.4 → qis-3.0.6}/qis/plots/derived/perf_table.py

@@ -125,6 +125,8 @@ def plot_ra_perf_table_benchmark(prices: pd.DataFrame,
                                  fontsize: int = 10,
                                  transpose: bool = False,
                                  alpha_an_factor: float = None,
+                                 is_convert_to_str: bool = True,
+                                 df_to_add: pd.DataFrame = None,
                                  ax: plt.Subplot = None,
                                  **kwargs
                                  ) -> Tuple[Optional[plt.Figure], pd.DataFrame]:
@@ -138,10 +140,19 @@ def plot_ra_perf_table_benchmark(prices: pd.DataFrame,
                                                   perf_columns=perf_columns,
                                                   column_header=column_header,
                                                   alpha_an_factor=alpha_an_factor,
+                                                  is_convert_to_str=is_convert_to_str,
                                                   **kwargs)
     if not drop_benchmark and special_rows_colors is None:
         special_rows_colors = [(1, 'skyblue')]  # for benchmarl separation
     kwargs = sop.update_kwargs(kwargs, dict(special_rows_colors=special_rows_colors))
+    
+    if df_to_add is not None:
+        df_to_add = df_to_add.reindex(index=ra_perf_table.index)
+        if is_convert_to_str:
+            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,

{qis-3.0.4 → qis-3.0.6}/qis/portfolio/multi_portfolio_data.py

@@ -427,6 +427,9 @@ class MultiPortfolioData:
                            time_period: TimePeriod = None,
                            perf_params: PerfParams = PERF_PARAMS,
                            perf_columns: List[PerfStat] = rpt.BENCHMARK_TABLE_COLUMNS,
+                           strategy_idx: int = 0,
+                           benchmark_idx: int = 1,
+                           add_turnover: bool = False,
                            ax: plt.Subplot = None,
                            **kwargs
                            ) -> pd.DataFrame:
@@ -437,6 +440,14 @@ class MultiPortfolioData:
             drop_benchmark = False
         ra_perf_title = f"RA performance table for {perf_params.freq_vol}-freq returns with beta to {benchmark}: " \
                         f"{qis.get_time_period(prices).to_str()}"
+        
+        if add_turnover:
+            turnover = self.get_turnover(time_period=time_period, **kwargs)
+            turnover = turnover.mean(axis=0).to_frame('Turnover')
+            df_to_add = qis.df_to_str(turnover, var_format='{:,.0%}')
+        else:
+            df_to_add = None
+            
         fig, ra_perf_table = ppt.plot_ra_perf_table_benchmark(prices=prices,
                                                               benchmark=benchmark,
                                                               perf_params=perf_params,
@@ -444,6 +455,7 @@ class MultiPortfolioData:
                                                               drop_benchmark=drop_benchmark,
                                                               title=ra_perf_title,
                                                               rotation_for_columns_headers=0,
+                                                              df_to_add=df_to_add,
                                                               ax=ax,
                                                               **kwargs)
         return ra_perf_table
@@ -598,7 +610,24 @@ class MultiPortfolioData:
                              **kwargs)
         if benchmark is not None:
             self.add_regime_shadows(ax=ax, regime_benchmark=benchmark, index=diff.index, regime_params=regime_params)
-
+    
+    def get_turnover(self,
+                     time_period: TimePeriod = None,
+                     turnover_rolling_period: Optional[int] = 12,
+                     freq_turnover: Optional[str] = 'ME',
+                     is_unit_based_traded_volume: bool = True,
+                     **kwargs
+                     ):
+        turnover = []
+        for portfolio in self.portfolio_datas:
+            turnover.append(portfolio.get_turnover(roll_period=turnover_rolling_period, freq=freq_turnover, is_agg=True,
+                                                   is_unit_based_traded_volume=is_unit_based_traded_volume).rename(
+                portfolio.nav.name))
+        turnover = pd.concat(turnover, axis=1)
+        if time_period is not None:
+            turnover = time_period.locate(turnover)
+        return turnover
+        
     def plot_turnover(self,
                       benchmark: str = None,
                       time_period: TimePeriod = None,
@@ -609,14 +638,10 @@ class MultiPortfolioData:
                       is_unit_based_traded_volume: bool = True,
                       ax: plt.Subplot = None,
                       **kwargs) -> None:
-
-        turnover = []
-        for portfolio in self.portfolio_datas:
-            turnover.append(portfolio.get_turnover(roll_period=turnover_rolling_period, freq=freq_turnover, is_agg=True,
-                                                   is_unit_based_traded_volume=is_unit_based_traded_volume).rename(portfolio.nav.name))
-        turnover = pd.concat(turnover, axis=1)
-        if time_period is not None:
-            turnover = time_period.locate(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)
         turnover_title = f"{turnover_rolling_period}-period rolling {freq}-freq Turnover"
         pts.plot_time_series(df=turnover,

{qis-3.0.4 → qis-3.0.6}/qis/portfolio/reports/strategy_benchmark_factsheet.py

@@ -542,6 +542,7 @@ def weights_tracking_error_report(multi_portfolio_data: MultiPortfolioData,
                                                                 add_benchmarks_to_navs=add_benchmarks_to_navs,
                                                                 perf_params=perf_params,
                                                                 time_period=time_period,
+                                                                add_turnover=True,
                                                                 ax=ax,
                                                                 **kwargs)
         dfs['ra_perf_table'] = ra_perf_table
@@ -556,11 +557,11 @@ def weights_tracking_error_report(multi_portfolio_data: MultiPortfolioData,
         fig, axs = plt.subplots(1, 2, figsize=figsize, tight_layout=True)
         qis.set_suptitle(fig, title=f"{strategy_data.ticker} Weights")
         figs['strategy_weights'] = fig
-        plot_exposures(exposures_short=exposures_short,
-                       exposures_long=exposures_long,
-                       ylabel='Weights',
-                       var_format=var_format,
-                       axs=axs,  **kwargs)
+        plot_exposures_long_short_groups(exposures_short=exposures_short,
+                                         exposures_long=exposures_long,
+                                         ylabel='Weights',
+                                         var_format=var_format,
+                                         axs=axs, **kwargs)
 
         rc_kwargs = dict(covar_dict=multi_portfolio_data.covar_dict, freq='QE')
         # strategy risk contributions
@@ -577,11 +578,11 @@ def weights_tracking_error_report(multi_portfolio_data: MultiPortfolioData,
         fig, axs = plt.subplots(1, 2, figsize=figsize, tight_layout=True)
         qis.set_suptitle(fig, title=f"{strategy_data.ticker} Risk Contributions")
         figs['strategy_var'] = fig
-        plot_exposures(exposures_short=qis.df_to_weight_allocation_sum1(risk_contributions_short),
-                       exposures_long=qis.df_to_weight_allocation_sum1(risk_contributions_long),
-                       ylabel='Risk Contributions',
-                       var_format=var_format,
-                       axs=axs, **kwargs)
+        plot_exposures_long_short_groups(exposures_short=qis.df_to_weight_allocation_sum1(risk_contributions_short),
+                                         exposures_long=qis.df_to_weight_allocation_sum1(risk_contributions_long),
+                                         ylabel='Risk Contributions',
+                                         var_format=var_format,
+                                         axs=axs, **kwargs)
 
         # benchmark weights
         benchmark_data = multi_portfolio_data.portfolio_datas[benchmark_idx]
@@ -593,11 +594,11 @@ def weights_tracking_error_report(multi_portfolio_data: MultiPortfolioData,
         fig, axs = plt.subplots(1, 2, figsize=figsize, tight_layout=True)
         qis.set_suptitle(fig, title=f"{benchmark_data.ticker} Weights")
         figs['benchmark_weights'] = fig
-        plot_exposures(exposures_short=benchmark_exposures_short,
-                       exposures_long=benchmark_exposures_long,
-                       ylabel='Weights',
-                       var_format=var_format,
-                       axs=axs, **kwargs)
+        plot_exposures_long_short_groups(exposures_short=benchmark_exposures_short,
+                                         exposures_long=benchmark_exposures_long,
+                                         ylabel='Weights',
+                                         var_format=var_format,
+                                         axs=axs, **kwargs)
 
         # benchmark var
         benchmark_risk_contributions_short = benchmark_data.compute_risk_contributions_implied_by_covar(
@@ -614,11 +615,11 @@ def weights_tracking_error_report(multi_portfolio_data: MultiPortfolioData,
         fig, axs = plt.subplots(1, 2, figsize=figsize, tight_layout=True)
         qis.set_suptitle(fig, title=f"{benchmark_data.ticker} Risk Contributions")
         figs['benchmark_var'] = fig
-        plot_exposures(exposures_short=qis.df_to_weight_allocation_sum1(benchmark_risk_contributions_short),
-                       exposures_long=qis.df_to_weight_allocation_sum1(benchmark_risk_contributions_long),
-                       ylabel='Risk Contributions',
-                       var_format=var_format,
-                       axs=axs, **kwargs)
+        plot_exposures_long_short_groups(exposures_short=qis.df_to_weight_allocation_sum1(benchmark_risk_contributions_short),
+                                         exposures_long=qis.df_to_weight_allocation_sum1(benchmark_risk_contributions_long),
+                                         ylabel='Risk Contributions',
+                                         var_format=var_format,
+                                         axs=axs, **kwargs)
 
         # turnover
         fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
@@ -653,14 +654,181 @@ def weights_tracking_error_report(multi_portfolio_data: MultiPortfolioData,
     return figs, dfs
 
 
-def plot_exposures(exposures_short: pd.DataFrame,
-                   exposures_long: pd.DataFrame,
-                   axs: List[plt.Subplot],
-                   ylabel: str = 'weights',
-                   var_format: str = '{:.1%}',
-                   hue_var_name: str = 'asset class',
-                   **kwargs
-                   ) -> None:
+def weights_tracking_error_report_cross(multi_portfolio_data: MultiPortfolioData,
+                                  strategy_idx: int = 0,
+                                  benchmark_idx: int = 1,
+                                  group_data: pd.Series = None,
+                                  group_order: List[str] = None,
+                                  group_data_short: pd.Series = None,
+                                  group_order_short: List[str] = None,
+                                  time_period: TimePeriod = None,
+                                  perf_params: PerfParams = PERF_PARAMS,
+                                  regime_params: BenchmarkReturnsQuantileRegimeSpecs = REGIME_PARAMS,
+                                  add_benchmarks_to_navs: bool = True,
+                                  figsize: Tuple[float, float] = (11.7, 8.3),
+                                  var_format: str = '{:.1%}',
+                                  **kwargs
+                                  ) -> Tuple[Dict[str, plt.Figure], Dict[str, pd.DataFrame]]:
+
+    regime_benchmark = multi_portfolio_data.benchmark_prices.columns[0]
+    benchmark_price = multi_portfolio_data.benchmark_prices[regime_benchmark]
+
+    figs = {}
+    dfs = {}
+    with sns.axes_style('darkgrid'):
+
+        # navs + ra table
+        fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
+        figs['navs'] = fig
+        multi_portfolio_data.plot_nav(regime_benchmark=regime_benchmark,
+                                      time_period=time_period,
+                                      perf_params=perf_params,
+                                      regime_params=regime_params,
+                                      add_benchmarks_to_navs=add_benchmarks_to_navs,
+                                      title=f"Cumulative performance with background colors using bear/normal/bull "
+                                            f"regimes of {regime_benchmark} {regime_params.freq}-returns",
+                                      ax=ax,
+                                      **kwargs)
+
+        fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
+        figs['ra_table'] = fig
+        ra_perf_table = multi_portfolio_data.plot_ra_perf_table(benchmark_price=benchmark_price,
+                                                                add_benchmarks_to_navs=add_benchmarks_to_navs,
+                                                                perf_params=perf_params,
+                                                                time_period=time_period,
+                                                                add_turnover=True,
+                                                                ax=ax,
+                                                                **kwargs)
+        dfs['ra_perf_table'] = ra_perf_table
+
+        # strategy weights
+        strategy_data = multi_portfolio_data.portfolio_datas[strategy_idx]
+        weight_kwargs = dict(is_grouped=True, time_period=time_period, add_total=False, is_input_weights=True)
+        strategy_exposures_short = strategy_data.get_weights(group_data=group_data_short, group_order=group_order_short,
+                                                    **weight_kwargs)
+        strategy_exposures_long = strategy_data.get_weights(group_data=group_data, group_order=group_order,
+                                                    **weight_kwargs)
+
+        # benchmark weights
+        benchmark_data = multi_portfolio_data.portfolio_datas[benchmark_idx]
+        benchmark_exposures_short = benchmark_data.get_weights(group_data=group_data_short, group_order=group_order_short,
+                                                               **weight_kwargs)
+        benchmark_exposures_long = benchmark_data.get_weights(group_data=group_data, group_order=group_order,
+                                                              **weight_kwargs)
+
+        # plot strategy and benchmark weights
+        fig, axs = plt.subplots(1, 2, figsize=figsize, tight_layout=True)
+        qis.set_suptitle(fig, title=f"{strategy_data.ticker} Weights")
+        figs['strategy_benchmark_weights_stack'] = fig
+        plot_exposures_strategy_vs_benchmark_stack(strategy_exposures=strategy_exposures_short,
+                                                   benchmark_exposures=benchmark_exposures_short,
+                                                   axs=axs,
+                                                   var_format=var_format,
+                                                   **kwargs)
+
+        # boxplot
+        fig, axs = plt.subplots(1, 2, figsize=figsize, tight_layout=True)
+        qis.set_suptitle(fig, title=f"{strategy_data.ticker} Weights")
+        figs['strategy_benchmark_weights_box'] = fig
+        plot_exposures_strategy_vs_benchmark_boxplot(strategy_exposures=strategy_exposures_short,
+                                                     benchmark_exposures=benchmark_exposures_short,
+                                                     ax=axs[0],
+                                                     ylabel='Weights',
+                                                     var_format=var_format,
+                                                     **kwargs)
+        plot_exposures_strategy_vs_benchmark_boxplot(strategy_exposures=strategy_exposures_long,
+                                                     benchmark_exposures=benchmark_exposures_long,
+                                                     ax=axs[1],
+                                                     ylabel='Weights',
+                                                     var_format=var_format,
+                                                     **kwargs)
+
+        # risk contributions
+        rc_kwargs = dict(covar_dict=multi_portfolio_data.covar_dict, freq='QE')
+        strategy_risk_contributions_short = strategy_data.compute_risk_contributions_implied_by_covar(
+            group_data=group_data_short,
+            group_order=group_order_short,
+            **rc_kwargs)
+        strategy_risk_contributions_short = qis.df_to_weight_allocation_sum1(strategy_risk_contributions_short)
+        strategy_risk_contributions_long = strategy_data.compute_risk_contributions_implied_by_covar(
+            group_data=group_data,
+            group_order=group_order,
+            **rc_kwargs)
+        strategy_risk_contributions_long = qis.df_to_weight_allocation_sum1(strategy_risk_contributions_long)
+
+        benchmark_risk_contributions_short = benchmark_data.compute_risk_contributions_implied_by_covar(
+            group_data=group_data_short,
+            group_order=group_order_short,
+            **rc_kwargs)
+        benchmark_risk_contributions_short = qis.df_to_weight_allocation_sum1(benchmark_risk_contributions_short)
+
+        benchmark_risk_contributions_long = benchmark_data.compute_risk_contributions_implied_by_covar(
+            group_data=group_data,
+            group_order=group_order,
+            **rc_kwargs)
+        benchmark_risk_contributions_long = qis.df_to_weight_allocation_sum1(benchmark_risk_contributions_long)
+
+        # stack
+        fig, axs = plt.subplots(1, 2, figsize=figsize, tight_layout=True)
+        qis.set_suptitle(fig, title=f"Time Series Risk Contributions")
+        figs['time_series_risk_contrib'] = fig
+        plot_exposures_strategy_vs_benchmark_stack(strategy_exposures=strategy_risk_contributions_short,
+                                                   benchmark_exposures=benchmark_risk_contributions_short,
+                                                   axs=axs,
+                                                   var_format=var_format,
+                                                   **kwargs)
+
+        # box plots
+        fig, axs = plt.subplots(1, 2, figsize=figsize, tight_layout=True)
+        qis.set_suptitle(fig, title=f"Risk Contributions")
+        figs['strategy_var'] = fig
+        plot_exposures_strategy_vs_benchmark_boxplot(
+            strategy_exposures=strategy_risk_contributions_short,
+            benchmark_exposures=benchmark_risk_contributions_short,
+            ax=axs[0],
+            ylabel='Risk Contributions',
+            var_format=var_format,
+            **kwargs)
+        plot_exposures_strategy_vs_benchmark_boxplot(
+            strategy_exposures=strategy_risk_contributions_long,
+            benchmark_exposures=benchmark_risk_contributions_long,
+            ax=axs[1],
+            ylabel='Risk Contributions',
+            var_format=var_format,
+            **kwargs)
+
+        fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
+        figs['tre_time_series'] = fig
+        multi_portfolio_data.plot_tre_time_series(strategy_idx=strategy_idx,
+                                                  benchmark_idx=benchmark_idx,
+                                                  ax=ax,
+                                                  time_period=time_period,
+                                                  **kwargs)
+
+        # brinson
+        fig, axs = plt.subplots(1, 2, figsize=figsize, tight_layout=True)
+        figs['brinson'] = fig
+        axs = [axs[0], axs[1], None, None, None]
+        multi_portfolio_data.plot_brinson_attribution(strategy_idx=strategy_idx,
+                                                      benchmark_idx=benchmark_idx,
+                                                      time_period=time_period,
+                                                      freq=None,
+                                                      axs=axs,
+                                                      total_column='Total Sum',
+                                                      is_exclude_interaction_term=True,
+                                                      **kwargs)
+
+    return figs, dfs
+
+
+def plot_exposures_long_short_groups(exposures_short: pd.DataFrame,
+                                     exposures_long: pd.DataFrame,
+                                     axs: List[plt.Subplot],
+                                     ylabel: str = 'weights',
+                                     var_format: str = '{:.1%}',
+                                     hue_var_name: str = 'asset class',
+                                     **kwargs
+                                     ) -> None:
     qis.plot_stack(df=exposures_short,
                    use_bar_plot=True,
                    legend_stats=qis.LegendStats.AVG_NONNAN_LAST,
@@ -682,3 +850,52 @@ def plot_exposures(exposures_short: pd.DataFrame,
                               y_limits=(0.0, None),
                               ax=axs[1],
                               **kwargs)
+
+
+def plot_exposures_strategy_vs_benchmark_stack(strategy_exposures: pd.DataFrame,
+                                               benchmark_exposures: pd.DataFrame,
+                                               axs: List[plt.Subplot],
+                                               var_format: str = '{:.1%}',
+                                               **kwargs
+                                               ) -> None:
+    qis.plot_stack(df=benchmark_exposures,
+                   use_bar_plot=True,
+                   legend_stats=qis.LegendStats.AVG_NONNAN_LAST,
+                   var_format=var_format,
+                   colors=qis.get_n_sns_colors(n=len(benchmark_exposures.columns)),
+                   title='SAA',
+                   ax=axs[0],
+                   **qis.update_kwargs(kwargs, dict(bbox_to_anchor=(0.5, 1.01), ncols=1,
+                                                    framealpha=0.9)))
+    qis.plot_stack(df=strategy_exposures,
+                   use_bar_plot=True,
+                   legend_stats=qis.LegendStats.AVG_NONNAN_LAST,
+                   var_format=var_format,
+                   colors=qis.get_n_sns_colors(n=len(strategy_exposures.columns)),
+                   title='TAA',
+                   ax=axs[1],
+                   **qis.update_kwargs(kwargs, dict(bbox_to_anchor=(0.5, 1.01), ncols=1,
+                                                    framealpha=0.9)))
+
+
+def plot_exposures_strategy_vs_benchmark_boxplot(strategy_exposures: pd.DataFrame,
+                                     benchmark_exposures: pd.DataFrame,
+                                     ax: plt.Subplot,
+                                     ylabel: str = 'weights',
+                                     var_format: str = '{:.1%}',
+                                     hue_var_name: str = 'asset class',
+                                     **kwargs
+                                     ) -> None:
+    dfs = dict(SAA=benchmark_exposures, TAA=strategy_exposures)
+    qis.df_dict_boxplot_by_columns(dfs=dfs,
+                                   hue_var_name=hue_var_name,
+                                   y_var_name=ylabel,
+                                   ylabel=ylabel,
+                                   showmedians=True,
+                                   add_y_median_labels=True,
+                                   yvar_format=var_format,
+                                   x_rotation=90,
+                                   # colors=qis.get_n_sns_colors(n=len(exposures_long.columns)),
+                                   y_limits=(0.0, None),
+                                   ax=ax,
+                                   **kwargs)

{qis-3.0.4 → qis-3.0.6}/qis/settings.yaml

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