qis 2.1.39__tar.gz → 2.1.40__tar.gz

{qis-2.1.39 → qis-2.1.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qis
-Version: 2.1.39
+Version: 2.1.40
 Summary: Implementation of visualisation and reporting analytics for Quantitative Investment Strategies
 License: LICENSE.txt
 Keywords: quantitative,investing,portfolio optimization,systematic strategies,volatility
@@ -174,16 +174,16 @@ fig = qis.plot_ra_perf_table(prices=prices,
 # add benchmark regression using excess returns for linear beta
 # regression frequency is specified using perf_params.freq_reg
 # regression alpha is multiplied using perf_params.alpha_an_factor
-fig = qis.plot_ra_perf_table_benchmark(prices=prices,
-                                       benchmark='SPY',
-                                       perf_columns=[PerfStat.TOTAL_RETURN, PerfStat.PA_RETURN, PerfStat.PA_EXCESS_RETURN,
-                                                     PerfStat.VOL, PerfStat.SHARPE_RF0,
-                                                     PerfStat.SHARPE_EXCESS, PerfStat.SORTINO_RATIO, PerfStat.CALMAR_RATIO,
-                                                     PerfStat.MAX_DD, PerfStat.MAX_DD_VOL,
-                                                     PerfStat.SKEWNESS, PerfStat.KURTOSIS,
-                                                     PerfStat.ALPHA_AN, PerfStat.BETA, PerfStat.R2],
-                                       title=f"Risk-adjusted performance: {qis.get_time_period_label(prices, date_separator='-')} benchmarked with SPY",
-                                       perf_params=perf_params)
+fig, _ = qis.plot_ra_perf_table_benchmark(prices=prices,
+                                          benchmark='SPY',
+                                          perf_columns=[PerfStat.TOTAL_RETURN, PerfStat.PA_RETURN, PerfStat.PA_EXCESS_RETURN,
+                                                        PerfStat.VOL, PerfStat.SHARPE_RF0,
+                                                        PerfStat.SHARPE_EXCESS, PerfStat.SORTINO_RATIO, PerfStat.CALMAR_RATIO,
+                                                        PerfStat.MAX_DD, PerfStat.MAX_DD_VOL,
+                                                        PerfStat.SKEWNESS, PerfStat.KURTOSIS,
+                                                        PerfStat.ALPHA_AN, PerfStat.BETA, PerfStat.R2],
+                                          title=f"Risk-adjusted performance: {qis.get_time_period_label(prices, date_separator='-')} benchmarked with SPY",
+                                          perf_params=perf_params)
 ```
 ![image info](qis/examples/figures/perf4.PNG)
 

{qis-2.1.39 → qis-2.1.40}/README.md

@@ -124,16 +124,16 @@ fig = qis.plot_ra_perf_table(prices=prices,
 # add benchmark regression using excess returns for linear beta
 # regression frequency is specified using perf_params.freq_reg
 # regression alpha is multiplied using perf_params.alpha_an_factor
-fig = qis.plot_ra_perf_table_benchmark(prices=prices,
-                                       benchmark='SPY',
-                                       perf_columns=[PerfStat.TOTAL_RETURN, PerfStat.PA_RETURN, PerfStat.PA_EXCESS_RETURN,
-                                                     PerfStat.VOL, PerfStat.SHARPE_RF0,
-                                                     PerfStat.SHARPE_EXCESS, PerfStat.SORTINO_RATIO, PerfStat.CALMAR_RATIO,
-                                                     PerfStat.MAX_DD, PerfStat.MAX_DD_VOL,
-                                                     PerfStat.SKEWNESS, PerfStat.KURTOSIS,
-                                                     PerfStat.ALPHA_AN, PerfStat.BETA, PerfStat.R2],
-                                       title=f"Risk-adjusted performance: {qis.get_time_period_label(prices, date_separator='-')} benchmarked with SPY",
-                                       perf_params=perf_params)
+fig, _ = qis.plot_ra_perf_table_benchmark(prices=prices,
+                                          benchmark='SPY',
+                                          perf_columns=[PerfStat.TOTAL_RETURN, PerfStat.PA_RETURN, PerfStat.PA_EXCESS_RETURN,
+                                                        PerfStat.VOL, PerfStat.SHARPE_RF0,
+                                                        PerfStat.SHARPE_EXCESS, PerfStat.SORTINO_RATIO, PerfStat.CALMAR_RATIO,
+                                                        PerfStat.MAX_DD, PerfStat.MAX_DD_VOL,
+                                                        PerfStat.SKEWNESS, PerfStat.KURTOSIS,
+                                                        PerfStat.ALPHA_AN, PerfStat.BETA, PerfStat.R2],
+                                          title=f"Risk-adjusted performance: {qis.get_time_period_label(prices, date_separator='-')} benchmarked with SPY",
+                                          perf_params=perf_params)
 ```
 ![image info](qis/examples/figures/perf4.PNG)
 

{qis-2.1.39 → qis-2.1.40}/pyproject.toml

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

{qis-2.1.39 → qis-2.1.40}/qis/examples/readme_performances.py

@@ -48,16 +48,16 @@ qis.save_fig(fig, file_name='perf3', local_path="figures/")
 # add benchmark regression using excess returns for linear beta
 # regression frequency is specified using perf_params.freq_reg
 # regression alpha is multiplied using perf_params.alpha_an_factor
-fig = qis.plot_ra_perf_table_benchmark(prices=prices,
-                                       benchmark='SPY',
-                                       perf_columns=[PerfStat.TOTAL_RETURN, PerfStat.PA_RETURN, PerfStat.PA_EXCESS_RETURN,
-                                                     PerfStat.VOL, PerfStat.SHARPE_RF0,
-                                                     PerfStat.SHARPE_EXCESS, PerfStat.SORTINO_RATIO, PerfStat.CALMAR_RATIO,
-                                                     PerfStat.MAX_DD, PerfStat.MAX_DD_VOL,
-                                                     PerfStat.SKEWNESS, PerfStat.KURTOSIS,
-                                                     PerfStat.ALPHA_AN, PerfStat.BETA, PerfStat.R2],
-                                       title=f"Risk-adjusted performance: {qis.get_time_period_label(prices, date_separator='-')} benchmarked with SPY",
-                                       perf_params=perf_params)
+fig, _ = qis.plot_ra_perf_table_benchmark(prices=prices,
+                                          benchmark='SPY',
+                                          perf_columns=[PerfStat.TOTAL_RETURN, PerfStat.PA_RETURN, PerfStat.PA_EXCESS_RETURN,
+                                                        PerfStat.VOL, PerfStat.SHARPE_RF0,
+                                                        PerfStat.SHARPE_EXCESS, PerfStat.SORTINO_RATIO, PerfStat.CALMAR_RATIO,
+                                                        PerfStat.MAX_DD, PerfStat.MAX_DD_VOL,
+                                                        PerfStat.SKEWNESS, PerfStat.KURTOSIS,
+                                                        PerfStat.ALPHA_AN, PerfStat.BETA, PerfStat.R2],
+                                          title=f"Risk-adjusted performance: {qis.get_time_period_label(prices, date_separator='-')} benchmarked with SPY",
+                                          perf_params=perf_params)
 # skip
 qis.save_fig(fig, file_name='perf4', local_path="figures/")
 

{qis-2.1.39 → qis-2.1.40}/qis/plots/derived/perf_table.py

@@ -125,10 +125,9 @@ def plot_ra_perf_table_benchmark(prices: pd.DataFrame,
                                  fontsize: int = 10,
                                  transpose: bool = False,
                                  alpha_an_factor: float = None,
-                                 is_df_out: bool = False,
                                  ax: plt.Subplot = None,
                                  **kwargs
-                                 ) -> Union[plt.Figure, Tuple[plt.Figure, pd.DataFrame]]:
+                                 ) -> Tuple[Optional[plt.Figure], pd.DataFrame]:
     """
     plot ra perf table and get ra performance columns with data as string for tables
     """
@@ -149,10 +148,7 @@ def plot_ra_perf_table_benchmark(prices: pd.DataFrame,
                             fontsize=fontsize,
                             ax=ax,
                             **kwargs)
-    if is_df_out:
-        return fig, ra_perf_table
-    else:
-        return fig
+    return fig, ra_perf_table
 
 
 def plot_ra_perf_bars(prices: pd.DataFrame,

{qis-2.1.39 → qis-2.1.40}/qis/portfolio/multi_portfolio_data.py

@@ -207,7 +207,7 @@ class MultiPortfolioData:
         for date, pd_covar in self.covar_dict.items():
             w = weight_diffs.loc[date]
             tracking_error[date] = np.sqrt(w @ pd_covar @ w.T)
-        tracking_error = pd.Series(tracking_error)
+        tracking_error = pd.Series(tracking_error, name='Tracking error')
         return tracking_error
 
     def compute_tracking_error_table(self,
@@ -427,10 +427,9 @@ class MultiPortfolioData:
                            time_period: TimePeriod = None,
                            perf_params: PerfParams = PERF_PARAMS,
                            perf_columns: List[PerfStat] = rpt.BENCHMARK_TABLE_COLUMNS,
-                           is_df_out: bool = False,
                            ax: plt.Subplot = None,
                            **kwargs
-                           ) -> Optional[pd.DataFrame]:
+                           ) -> pd.DataFrame:
         if benchmark is None:
             benchmark = self.benchmark_prices.columns[0]
         prices = self.get_navs(time_period=time_period, benchmark=benchmark, add_benchmarks_to_navs=add_benchmarks_to_navs)
@@ -445,11 +444,9 @@ class MultiPortfolioData:
                                                               drop_benchmark=drop_benchmark,
                                                               title=ra_perf_title,
                                                               rotation_for_columns_headers=0,
-                                                              is_df_out=is_df_out,
                                                               ax=ax,
                                                               **kwargs)
-        if is_df_out:
-            return ra_perf_table
+        return ra_perf_table
 
     def plot_ac_ra_perf_table(self,
                               benchmark_price: pd.Series,

{qis-2.1.39 → qis-2.1.40}/qis/portfolio/portfolio_data.py

@@ -709,25 +709,33 @@ class PortfolioData:
     def compute_risk_contributions_implied_by_covar(self,
                                                     covar_dict: Dict[pd.Timestamp, pd.DataFrame],
                                                     group_data: pd.Series = None,
-                                                    group_order: List[str] = None
+                                                    group_order: List[str] = None,
+                                                    align_with_covar_dates: bool = True,
+                                                    freq: Optional[str] = None
                                                     ) -> pd.DataFrame:
         """
         compute risk contributions using covar_dict
         """
-        strategy_weights = self.get_weights(freq=None, is_input_weights=True)
+        strategy_weights = self.get_weights(freq=freq, is_input_weights=True)
         covar_index = list(covar_dict.keys())
-        strategy_weights = strategy_weights.reindex(index=covar_index).ffill().fillna(0.0)
         strategy_rc = {}
-        for date, pd_covar in covar_dict.items():
-            strategy_rc[date] = compute_portfolio_risk_contributions(w=strategy_weights.loc[date], covar=pd_covar)
-        strategy_rc = pd.DataFrame.from_dict(strategy_rc, orient='index')
+        if align_with_covar_dates:
+            strategy_weights = strategy_weights.reindex(index=covar_index).ffill().fillna(0.0)
+            for date, pd_covar in covar_dict.items():
+                strategy_rc[date] = compute_portfolio_risk_contributions(w=strategy_weights.loc[date], covar=pd_covar)
+        else:
+            for date, weights in strategy_weights.to_dict(orient='index').items():
+                last_covar_update_date = qis.find_upto_date_from_datetime_index(index=covar_index, date=date)
+                if last_covar_update_date is not None:
+                    strategy_rc[date] = compute_portfolio_risk_contributions(w=pd.Series(weights).fillna(0.0),
+                                                                             covar=covar_dict[last_covar_update_date])
 
+        strategy_rc = pd.DataFrame.from_dict(strategy_rc, orient='index')
         if group_data is not None:
             strategy_rc = dfg.agg_df_by_groups_ax1(strategy_rc, group_data=group_data, group_order=group_order)
 
         return strategy_rc
 
-
     # """
     # plotting methods
     # """

{qis-2.1.39 → qis-2.1.40}/qis/portfolio/reports/strategy_benchmark_factsheet.py

@@ -531,7 +531,8 @@ def weights_tracking_error_report(multi_portfolio_data: MultiPortfolioData,
                                       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 regimes of {regime_benchmark} {regime_params.freq}-returns",
+                                      title=f"Cumulative performance with background colors using bear/normal/bull "
+                                            f"regimes of {regime_benchmark} {regime_params.freq}-returns",
                                       ax=ax,
                                       **kwargs)
 
@@ -541,7 +542,6 @@ 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,
-                                                                is_df_out=True,
                                                                 ax=ax,
                                                                 **kwargs)
         dfs['ra_perf_table'] = ra_perf_table
@@ -559,18 +559,23 @@ def weights_tracking_error_report(multi_portfolio_data: MultiPortfolioData,
         plot_exposures(exposures_short=exposures_short,
                        exposures_long=exposures_long,
                        ylabel='Weights',
-                       var_format=var_format, y_limits=(0.0, None),
+                       var_format=var_format,
                        axs=axs,  **kwargs)
 
+        rc_kwargs = dict(covar_dict=multi_portfolio_data.covar_dict, freq='QE')
         # strategy risk contributions
-        risk_contributions_short = strategy_data.compute_risk_contributions_implied_by_covar(covar_dict=multi_portfolio_data.covar_dict,
-                                                                                             group_data=group_data_short,
-                                                                                             group_order=group_order_short)
-        risk_contributions_long = strategy_data.compute_risk_contributions_implied_by_covar(covar_dict=multi_portfolio_data.covar_dict,
-                                                                                             group_data=group_data,
-                                                                                             group_order=group_order)
+        risk_contributions_short = strategy_data.compute_risk_contributions_implied_by_covar(group_data=group_data_short,
+                                                                                             group_order=group_order_short,
+                                                                                             **rc_kwargs)
+        risk_contributions_long = strategy_data.compute_risk_contributions_implied_by_covar(group_data=group_data,
+                                                                                            group_order=group_order,
+                                                                                            **rc_kwargs)
+        # ungrouped
+        dfs['strategy_risk_contributions'] = strategy_data.compute_risk_contributions_implied_by_covar(**rc_kwargs)
+
+
         fig, axs = plt.subplots(1, 2, figsize=figsize, tight_layout=True)
-        qis.set_suptitle(fig, title=f"{strategy_data.ticker} Var")
+        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),
@@ -591,18 +596,21 @@ def weights_tracking_error_report(multi_portfolio_data: MultiPortfolioData,
         plot_exposures(exposures_short=benchmark_exposures_short,
                        exposures_long=benchmark_exposures_long,
                        ylabel='Weights',
-                       var_format=var_format, y_limits=(0.0, None),
+                       var_format=var_format,
                        axs=axs, **kwargs)
 
         # benchmark var
         benchmark_risk_contributions_short = benchmark_data.compute_risk_contributions_implied_by_covar(
-            covar_dict=multi_portfolio_data.covar_dict,
             group_data=group_data_short,
-            group_order=group_order_short)
+            group_order=group_order_short,
+            **rc_kwargs)
         benchmark_risk_contributions_long = benchmark_data.compute_risk_contributions_implied_by_covar(
-            covar_dict=multi_portfolio_data.covar_dict,
             group_data=group_data,
-            group_order=group_order)
+            group_order=group_order,
+            **rc_kwargs)
+        # ungrouped
+        dfs['benchmark_risk_contributions'] = benchmark_data.compute_risk_contributions_implied_by_covar(**rc_kwargs)
+
         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
@@ -613,9 +621,9 @@ def weights_tracking_error_report(multi_portfolio_data: MultiPortfolioData,
                        axs=axs, **kwargs)
 
         # turnover
-        fig, axs = plt.subplots(1, 2, figsize=figsize, tight_layout=True)
+        fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
         figs['turnover'] = fig
-        multi_portfolio_data.plot_turnover(ax=axs[0],
+        multi_portfolio_data.plot_turnover(ax=ax,
                                            time_period=time_period,
                                            #turnover_rolling_period=260,
                                            #freq_turnover=None,
@@ -660,5 +668,6 @@ def plot_exposures(exposures_short: pd.DataFrame,
                               yvar_format=var_format,
                               x_rotation=90,
                               colors=qis.get_n_sns_colors(n=len(exposures_long.columns)),
+                              y_limits=(0.0, None),
                               ax=axs[1],
                               **kwargs)