qis 3.2.8__tar.gz → 3.2.10__tar.gz

{qis-3.2.8 → qis-3.2.10}/PKG-INFO

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

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

{qis-3.2.8 → qis-3.2.10}/qis/portfolio/multi_portfolio_data.py

@@ -192,8 +192,12 @@ class MultiPortfolioData:
 
     def compute_tracking_error_implied_by_covar(self,
                                                 strategy_idx: int = 0,
-                                                benchmark_idx: int = 1
-                                                ) -> pd.Series:
+                                                benchmark_idx: int = 1,
+                                                is_grouped: bool = False,
+                                                group_data: pd.Series = None,
+                                                group_order: List[str] = None,
+                                                total_column: Optional[str] = 'Total'
+                                                ) -> Union[pd.Series, pd.DataFrame]:
         """
         compute Ex ante  tracking error =
         (strategy_weights - strategy_weights) @ covar @ (strategy_weights - strategy_weights).T
@@ -208,11 +212,33 @@ class MultiPortfolioData:
         benchmark_weights = benchmark_weights.reindex(index=covar_index, columns=investable_assets).ffill().fillna(0.0)
 
         weight_diffs = benchmark_weights - strategy_weights
-        tracking_error = {}
-        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, name='Tracking error')
+        if not is_grouped:
+            tracking_error = {}
+            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, name='Tracking error')
+        else:
+            if group_data is None:
+                group_data = self.portfolio_datas[strategy_idx].group_data
+            if group_order is None:
+                group_order = self.portfolio_datas[strategy_idx].group_order
+            group_dict = dfg.get_group_dict(group_data=group_data,
+                                            group_order=group_order,
+                                            total_column=total_column)
+            tracking_error = {key: {} for key in group_dict.keys()}
+            for date, pd_covar in self.covar_dict.items():
+                w = weight_diffs.loc[date]
+                for key, tickers in group_dict.items():
+                    w_g = w.loc[tickers]
+                    pd_covar_g = pd_covar.loc[tickers, tickers]
+                    tracking_error[key][date] = np.sqrt(w_g @ pd_covar_g @ w_g.T)
+            # merge
+            tracking_error_pd = {}
+            for key in group_dict.keys():
+                tracking_error_pd[key] = pd.Series(tracking_error[key], name=key)
+            tracking_error = pd.DataFrame.from_dict(tracking_error_pd, orient='columns')
+
         return tracking_error
 
     def compute_tracking_error_table(self,
@@ -620,7 +646,7 @@ class MultiPortfolioData:
                              **kwargs)
         if regime_benchmark is not None:
             self.add_regime_shadows(ax=ax, regime_benchmark=regime_benchmark, index=diff.index, regime_params=regime_params)
-    
+
     def get_turnover(self,
                      time_period: TimePeriod = None,
                      turnover_rolling_period: Optional[int] = 12,
@@ -637,7 +663,7 @@ class MultiPortfolioData:
         if time_period is not None:
             turnover = time_period.locate(turnover)
         return turnover
-        
+
     def plot_turnover(self,
                       regime_benchmark: str = None,
                       time_period: TimePeriod = None,
@@ -648,7 +674,7 @@ class MultiPortfolioData:
                       is_unit_based_traded_volume: bool = True,
                       ax: plt.Subplot = None,
                       **kwargs) -> None:
-        
+
         turnover = self.get_turnover(turnover_rolling_period=turnover_rolling_period,
                                      freq_turnover=freq_turnover,
                                      is_unit_based_traded_volume=is_unit_based_traded_volume,
@@ -1007,21 +1033,39 @@ class MultiPortfolioData:
     def plot_tre_time_series(self,
                              strategy_idx: int = 0,
                              benchmark_idx: int = 1,
+                             is_grouped: bool = False,
+                             group_data: pd.Series = None,
+                             group_order: List[str] = None,
                              regime_benchmark: str = None,
                              regime_params: BenchmarkReturnsQuantileRegimeSpecs = REGIME_PARAMS,
                              time_period: TimePeriod = None,
                              title: Optional[str] = 'Tracking error',
+                             total_column: Optional[str] = 'Total',
                              var_format: str = '{:.2%}',
+                             tre_max_clip: Optional[float] = None,
                              ax: plt.Subplot = None,
                              **kwargs
                              ) -> None:
-        tre = self.compute_tracking_error_implied_by_covar(strategy_idx=strategy_idx, benchmark_idx=benchmark_idx)
+        tre = self.compute_tracking_error_implied_by_covar(strategy_idx=strategy_idx, benchmark_idx=benchmark_idx,
+                                                           is_grouped=is_grouped, group_data=group_data,
+                                                           group_order=group_order,
+                                                           total_column=total_column)
+        if tre_max_clip is not None:
+            if isinstance(tre, pd.DataFrame):  # skip total_column from trimming
+                tre_columns = tre.columns.to_list()
+                if total_column in tre:
+                    tre_columns.remove(total_column)
+                tre[tre_columns] = tre[tre_columns].clip(upper=tre_max_clip)
+            else:
+                tre = tre.clip(upper=tre_max_clip)
+
         if time_period is not None:
             tre = time_period.locate(tre)
         pts.plot_time_series(df=tre,
                              var_format=var_format,
                              legend_stats=pts.LegendStats.AVG_NONNAN_LAST,
                              title=title,
+                             y_limits=(0.0, None),
                              ax=ax,
                              **kwargs)
         if regime_benchmark is not None:

{qis-3.2.8 → qis-3.2.10}/qis/portfolio/portfolio_data.py

@@ -1484,10 +1484,10 @@ class PortfolioData:
                       group_data: pd.Series = None,
                       group_order: List[str] = None,
                       time_period: TimePeriod = None,
-                      roll_period: Optional[int] = 260,
+                      turnover_rolling_period: Optional[int] = 260,
+                      freq_turnover: Optional[str] = 'B',
                       add_total: bool = True,
                       title: str = None,
-                      freq: Optional[str] = None,
                       regime_params: BenchmarkReturnsQuantileRegimeSpecs = None,
                       ax: plt.Subplot = None,
                       **kwargs
@@ -1497,19 +1497,20 @@ class PortfolioData:
                                      group_data=group_data,
                                      group_order=group_order,
                                      time_period=time_period,
-                                     roll_period=roll_period,
+                                     roll_period=turnover_rolling_period,
                                      add_total=add_total,
-                                     freq=freq,
+                                     freq=freq_turnover,
                                      **kwargs)
-        turnover_title = title or f"{roll_period}-period rolling {freq}-freq Turnover"
+        freq = pd.infer_freq(turnover.index)
+        turnover_title = title or f"{turnover_rolling_period}-period rolling {freq}-freq Turnover"
         qis.plot_time_series(df=turnover,
-                             var_format='{:,.2%}',
-                             # y_limits=(0.0, None),
+                             var_format='{:,.1%}',
+                             y_limits=(0.0, None),
                              legend_stats=qis.LegendStats.AVG_NONNAN_LAST,
                              title=turnover_title,
                              ax=ax,
                              **kwargs)
-        if regime_benchmark is not None:
+        if regime_benchmark is not None and self.benchmark_prices is not None:
             self.add_regime_shadows(ax=ax, regime_benchmark=regime_benchmark, index=turnover.index,
                                     regime_params=regime_params)
 

{qis-3.2.8 → qis-3.2.10}/qis/portfolio/reports/strategy_benchmark_factsheet.py

@@ -513,6 +513,7 @@ def weights_tracking_error_report_by_ac_subac(multi_portfolio_data: MultiPortfol
                                               perf_params: PerfParams = PERF_PARAMS,
                                               regime_params: BenchmarkReturnsQuantileRegimeSpecs = REGIME_PARAMS,
                                               add_benchmarks_to_navs: bool = True,
+                                              tre_max_clip: Optional[float] = None,
                                               figsize: Tuple[float, float] = (11.7, 8.3),
                                               var_format: str = '{:.1%}',
                                               add_titles: bool = True,
@@ -665,22 +666,6 @@ def weights_tracking_error_report_by_ac_subac(multi_portfolio_data: MultiPortfol
             allow_negative=True,
             **kwargs)
 
-        # tracking error
-        fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
-        figs['tre_time_series'] = fig
-        if add_titles:
-            title = 'Tracking Error'
-        else:
-            title = None
-        multi_portfolio_data.plot_tre_time_series(strategy_idx=strategy_idx,
-                                                  benchmark_idx=benchmark_idx,
-                                                  regime_benchmark=regime_benchmark,
-                                                  regime_params=regime_params,
-                                                  title=title,
-                                                  ax=ax,
-                                                  time_period=time_period,
-                                                  **kwargs)
-
         # brinson by asset class
         totals_table, active_total, grouped_allocation_return, grouped_selection_return, grouped_interaction_return = \
             multi_portfolio_data.compute_brinson_attribution(strategy_idx=strategy_idx,
@@ -744,6 +729,42 @@ def weights_tracking_error_report_by_ac_subac(multi_portfolio_data: MultiPortfol
         figs['brinson_table_subac'] = qis.plot_brinson_totals_table(totals_table=totals_table, **kwargs)
         dfs['brinson_table_subac'] = totals_table
 
+        # tracking error
+        fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
+        figs['tre_time_series'] = fig
+        if add_titles:
+            title = 'Tracking Error'
+        else:
+            title = None
+        multi_portfolio_data.plot_tre_time_series(strategy_idx=strategy_idx,
+                                                  benchmark_idx=benchmark_idx,
+                                                  regime_benchmark=regime_benchmark,
+                                                  regime_params=regime_params,
+                                                  title=title,
+                                                  ax=ax,
+                                                  time_period=time_period,
+                                                  **kwargs)
+
+        # group tracking error
+        fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
+        figs['tre_group_time_series'] = fig
+        if add_titles:
+            title = 'Asset Class Tracking Error'
+        else:
+            title = None
+        multi_portfolio_data.plot_tre_time_series(strategy_idx=strategy_idx,
+                                                  benchmark_idx=benchmark_idx,
+                                                  is_grouped=True,
+                                                  group_data=ac_group_data,
+                                                  group_order=ac_group_order,
+                                                  regime_benchmark=regime_benchmark,
+                                                  regime_params=regime_params,
+                                                  tre_max_clip=tre_max_clip,
+                                                  title=title,
+                                                  ax=ax,
+                                                  time_period=time_period,
+                                                  **kwargs)
+
         # turnover
         fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
         figs['joint_turnover'] = fig
@@ -751,9 +772,9 @@ def weights_tracking_error_report_by_ac_subac(multi_portfolio_data: MultiPortfol
                                            time_period=time_period,
                                            regime_benchmark=regime_benchmark,
                                            regime_params=regime_params,
-                                           #turnover_rolling_period=260,
-                                           #freq_turnover=None,
                                            **kwargs)
+        if not add_titles:
+            ax.title.set_visible(False)
         # group turnover
         fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
         figs['group_turnover'] = fig
@@ -765,10 +786,12 @@ def weights_tracking_error_report_by_ac_subac(multi_portfolio_data: MultiPortfol
                                                                          group_data=turnover_groups,
                                                                          group_order=turnover_order,
                                                                          add_total=False,
-                                                                         #turnover_rolling_period=260,
-                                                                         #freq_turnover=None,
                                                                          **kwargs)
-
+        if regime_benchmark is not None:
+            multi_portfolio_data.add_regime_shadows(ax=ax, regime_benchmark=regime_benchmark,
+                                                    index=grouped_selection_return.index, regime_params=regime_params)
+        if not add_titles:
+            ax.title.set_visible(False)
     return figs, dfs