qis 3.0.2__tar.gz → 3.0.4__tar.gz

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

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

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

{qis-3.0.2 → qis-3.0.4}/qis/portfolio/ewm_portfolio_risk.py

@@ -75,9 +75,11 @@ def compute_portfolio_vol(returns: pd.DataFrame,
                                               init_type=init_type,
                                               nan_backfill=nan_backfill)
 
+    if span is not None:
+        ewm_lambda = 1.0 - 2.0 / (span + 1.0)
+
     portfolio_vol = compute_portfolio_var_np(returns=returns_np,
                                              weights=weights_np,
-                                             span=span,
                                              ewm_lambda=ewm_lambda)
 
     if annualize:
@@ -215,7 +217,13 @@ def compute_portfolio_independent_var_by_ac(prices: pd.DataFrame,
 def compute_portfolio_risk_contributions(w: Union[np.ndarray, pd.Series],
                                          covar: Union[np.ndarray, pd.DataFrame]
                                          ) -> Union[np.ndarray, pd.Series]:
+    if isinstance(covar, pd.DataFrame) and isinstance(w, pd.Series):  # make sure weights are alined
+        w = w.reindex(index=covar.index).fillna(0.0)
+    elif isinstance(covar, np.ndarray) and isinstance(w, np.ndarray):
+        assert covar.shape[0] == covar.shape[1] == w.shape[0]
+    else:
+        raise ValueError(f"unnsuported types {type(w)} and {type(covar)}")
     portfolio_vol = np.sqrt(w.T @ covar @ w)
     marginal_risk_contribution = covar @ w.T
     rc = np.multiply(marginal_risk_contribution, w) / portfolio_vol
-    return rc
+    return rc

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

@@ -216,7 +216,7 @@ class MultiPortfolioData:
                                      freq: Optional[str] = 'B',
                                      time_period: TimePeriod = None,
                                      af: float = 260,
-                                     is_norm_costs: bool = True,
+                                     is_unit_based_traded_volume: bool = True,
                                      **kwargs
                                      ) -> pd.DataFrame:
         """
@@ -238,7 +238,7 @@ class MultiPortfolioData:
                                                                             roll_period=None, add_total=False)
         strategy_cost = self.portfolio_datas[strategy_idx].get_costs(time_period=time_period, freq=freq,
                                                                      roll_period=None,
-                                                                     add_total=False, is_norm_costs=is_norm_costs)
+                                                                     add_total=False, is_unit_based_traded_volume=is_unit_based_traded_volume)
         strategy_ticker = self.portfolio_datas[strategy_idx].ticker
 
         # benchmark_weights = self.portfolio_datas[benchmark_idx].get_weights(time_period=time_period, freq=None, is_input_weights=True)
@@ -246,7 +246,7 @@ class MultiPortfolioData:
                                                                               roll_period=None, add_total=False)
         benchmark_cost = self.portfolio_datas[benchmark_idx].get_costs(time_period=time_period, freq=freq,
                                                                        roll_period=None,
-                                                                       add_total=False, is_norm_costs=is_norm_costs)
+                                                                       add_total=False, is_unit_based_traded_volume=is_unit_based_traded_volume)
         benchmark_ticker = self.portfolio_datas[benchmark_idx].ticker
 
         # compute stats
@@ -606,12 +606,14 @@ class MultiPortfolioData:
                       turnover_rolling_period: Optional[int] = 260,
                       freq_turnover: Optional[str] = 'B',
                       var_format: str = '{:.0%}',
+                      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).rename(portfolio.nav.name))
+            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)
@@ -635,13 +637,13 @@ class MultiPortfolioData:
                    time_period: TimePeriod = None,
                    regime_params: BenchmarkReturnsQuantileRegimeSpecs = REGIME_PARAMS,
                    var_format: str = '{:.2%}',
-                   is_norm_costs: bool = True,
+                   is_unit_based_traded_volume: bool = True,
                    ax: plt.Subplot = None,
                    **kwargs) -> None:
         costs = []
         for portfolio in self.portfolio_datas:
             costs.append(portfolio.get_costs(roll_period=cost_rolling_period, freq=freq_cost, is_agg=True,
-                                             is_norm_costs=is_norm_costs).rename(portfolio.nav.name))
+                                             is_unit_based_traded_volume=is_unit_based_traded_volume).rename(portfolio.nav.name))
         costs = pd.concat(costs, axis=1)
         if time_period is not None:
             costs = time_period.locate(costs)

{qis-3.0.2 → qis-3.0.4}/qis/portfolio/portfolio_data.py

@@ -167,13 +167,13 @@ class PortfolioData:
                             add_total: bool = False,
                             time_period: TimePeriod = None,
                             is_net: bool = False,
-                            is_norm_costs: bool = True,
+                            is_unit_based_traded_volume: bool = True,
                             is_compounded: bool = False,
                             freq: Optional[str] = None
                             ) -> pd.DataFrame:
         pnl = self.instrument_pnl.copy()
         if is_net:
-            costs = self.get_costs(add_total=False, is_norm_costs=is_norm_costs)
+            costs = self.get_costs(add_total=False, is_unit_based_traded_volume=is_unit_based_traded_volume)
             pnl = pnl.subtract(costs)
         if add_total:
             pnl.insert(loc=0, value=pnl.sum(1), column='Total')
@@ -335,12 +335,17 @@ class PortfolioData:
                      is_vol_adjusted: bool = False,
                      add_total: bool = True,
                      vol_span: int = 33,
-                     freq: Optional[str] = None
+                     freq: Optional[str] = None,
+                     is_unit_based_traded_volume: bool = True
                      ) -> Union[pd.DataFrame, pd.Series]:
-        turnover = (self.units.diff(1).abs()).multiply(self.prices)
-        abs_exposure = self.units.multiply(self.prices).abs().sum(axis=1)
-        # turnover = turnover.divide(self.nav.to_numpy(), axis=0)
-        turnover = turnover.divide(abs_exposure.to_numpy(), axis=0)
+
+        if is_unit_based_traded_volume:  # for unit generated backtest
+            turnover = (self.units.diff(1).abs()).multiply(self.prices)
+            abs_exposure = self.units.multiply(self.prices).abs().sum(axis=1)
+            # turnover = turnover.divide(self.nav.to_numpy(), axis=0)
+            turnover = turnover.divide(abs_exposure.to_numpy(), axis=0)
+        else:  # for weight generated backtets
+            turnover = self.input_weights.diff(1).abs()
 
         if is_vol_adjusted:
             instrument_vols = compute_ewm_vol(data=qis.to_returns(self.prices, is_log_returns=True),
@@ -374,13 +379,13 @@ class PortfolioData:
                   is_grouped: bool = False,
                   time_period: TimePeriod = None,
                   add_total: bool = True,
-                  is_norm_costs: bool = True,
+                  is_unit_based_traded_volume: bool = True,
                   roll_period: Optional[int] = 260,
                   freq: Optional[str] = None
                   ) -> Union[pd.DataFrame, pd.Series]:
 
         costs = self.realized_costs
-        if is_norm_costs:
+        if is_unit_based_traded_volume:
             costs = costs.divide(self.nav.to_numpy(), axis=0)
         if is_agg:
             costs = pd.Series(np.nansum(costs, axis=1), index=self.nav.index, name=self.nav.name)
@@ -533,7 +538,7 @@ class PortfolioData:
     def get_performance_attribution_data(self,
                                          attribution_metric: AttributionMetric = AttributionMetric.PNL,
                                          time_period: TimePeriod = None,
-                                         is_norm_costs: bool = True,
+                                         is_unit_based_traded_volume: bool = True,
                                          **kwargs
                                          ) -> Union[pd.DataFrame, pd.Series]:
         if attribution_metric == AttributionMetric.PNL:
@@ -543,11 +548,11 @@ class PortfolioData:
         elif attribution_metric == AttributionMetric.INST_PNL:
             data = self.get_instruments_navs(time_period=time_period)
         elif attribution_metric == AttributionMetric.COSTS:
-            data = self.get_costs(is_agg=False, is_grouped=False, roll_period=None, is_norm_costs=is_norm_costs,
+            data = self.get_costs(is_agg=False, is_grouped=False, roll_period=None, is_unit_based_traded_volume=is_unit_based_traded_volume,
                                   add_total=False,
                                   time_period=time_period)
             data = data.sum(0)
-            #print(f"total costs, is_norm_costs={is_norm_costs} = {np.nansum(data)}")
+            #print(f"total costs, is_unit_based_traded_volume={is_unit_based_traded_volume} = {np.nansum(data)}")
         elif attribution_metric == AttributionMetric.TURNOVER:
             data = self.get_turnover(is_agg=False, is_grouped=False, roll_period=None,
                                      add_total=False,

{qis-3.0.2 → qis-3.0.4}/qis/portfolio/reports/config.py

@@ -3,6 +3,8 @@ configuration for performance reports
 """
 from enum import Enum
 from typing import Dict, Any, Tuple, NamedTuple, Optional, List
+
+import qis
 from qis import PerfParams, BenchmarkReturnsQuantileRegimeSpecs, TimePeriod, PerfStat
 import yfinance as yf
 
@@ -61,7 +63,7 @@ class FactsheetConfig(NamedTuple):
     freq_turnover: str = 'B'   # daily freq
     cost_rolling_period: int = 260  # turnover = turnover.rolling(turnover_roll_period).sum()
     freq_cost: Optional[str] = 'B'  # for rolling costs
-    is_norm_costs: bool = True  # for long-only protfolio use nrmalised costs
+    is_unit_based_traded_volume: bool = True  # for long-only protfolio use nrmalised costs
     factor_beta_span: int = 52  # to compute rolling beta
     freq_beta: str = 'W-WED'  # for scatter plot
     exposures_freq: str = 'W-WED'  # for plotting strategy exposures
@@ -101,7 +103,7 @@ FACTSHEET_CONFIG_MONTHLY_DATA_LONG_PERIOD = FactsheetConfig(freq='ME',
                                                             freq_cost='ME',
                                                             freq_var='ME',
                                                             var_span=12,
-                                                            is_norm_costs=True,
+                                                            is_unit_based_traded_volume=True,
                                                             factor_beta_span=36,
                                                             freq_beta='ME',
                                                             exposures_freq='ME')
@@ -124,7 +126,7 @@ FACTSHEET_CONFIG_QUARTERLY_DATA_LONG_PERIOD = FactsheetConfig(freq='QE',
                                                               freq_cost='QE',
                                                               freq_var='QE',
                                                               var_span=12,
-                                                              is_norm_costs=True,
+                                                              is_unit_based_traded_volume=True,
                                                               factor_beta_span=12,
                                                               freq_beta='QE',
                                                               exposures_freq='QE')
@@ -178,7 +180,8 @@ def fetch_default_perf_params() -> Tuple[PerfParams, BenchmarkReturnsQuantileReg
 def fetch_default_report_kwargs(time_period: Optional[TimePeriod] = None,
                                 reporting_frequency: ReportingFrequency = ReportingFrequency.DAILY,
                                 long_threshold_years: float = 5.0,
-                                add_rates_data: bool = True
+                                add_rates_data: bool = True,
+                                is_unit_based_traded_volume: bool = True
                                 ) -> Dict[str, Any]:
 
     # use for number years > 5
@@ -207,6 +210,7 @@ def fetch_default_report_kwargs(time_period: Optional[TimePeriod] = None,
 
     kwargs = fetch_factsheet_config_kwargs(factsheet_config=factsheet_config,
                                            add_rates_data=add_rates_data)
+    kwargs = qis.update_kwargs(kwargs, dict(is_unit_based_traded_volume=is_unit_based_traded_volume))
     return kwargs
 
 

{qis-3.0.2 → qis-3.0.4}/qis/portfolio/reports/strategy_factsheet.py

@@ -51,7 +51,7 @@ def generate_strategy_factsheet(portfolio_data: PortfolioData,
                                 is_1y_exposures: bool = False,
                                 is_grouped: Optional[bool] = None,
                                 dd_legend_type: qis.DdLegendType = qis.DdLegendType.SIMPLE,
-                                is_norm_costs: bool = True,
+                                is_unit_based_traded_volume: bool = True,
                                 df_to_add: pd.DataFrame = None,
                                 factsheet_name: str = None,
                                 **kwargs
@@ -157,7 +157,8 @@ def generate_strategy_factsheet(portfolio_data: PortfolioData,
     ax = fig.add_subplot(gs[10:12, :2])
     turnover = portfolio_data.get_turnover(time_period=time_period, roll_period=turnover_rolling_period,
                                            freq=freq_turnover,
-                                           is_grouped=is_grouped)
+                                           is_grouped=is_grouped,
+                                           is_unit_based_traded_volume=is_unit_based_traded_volume)
     freq = pd.infer_freq(turnover.index)
     turnover_title = f"{turnover_rolling_period}-period rolling {freq}-freq Turnover"
     qis.plot_time_series(df=turnover,
@@ -175,7 +176,7 @@ def generate_strategy_factsheet(portfolio_data: PortfolioData,
     costs = portfolio_data.get_costs(time_period=time_period, roll_period=cost_rolling_period,
                                      freq=freq_cost,
                                      is_grouped=is_grouped,
-                                     is_norm_costs=is_norm_costs)
+                                     is_unit_based_traded_volume=is_unit_based_traded_volume)
     freq = pd.infer_freq(costs.index)
     costs_title = f"{cost_rolling_period}-period rolling {freq}-freq Costs"
     qis.plot_time_series(df=costs,
@@ -510,7 +511,7 @@ def generate_strategy_factsheet(portfolio_data: PortfolioData,
 
         # costs
         with sns.axes_style("whitegrid"):
-            local_kwargs = qis.update_kwargs(kwargs=kwargs, new_kwargs=dict(legend_loc=None, is_norm_costs=is_norm_costs))
+            local_kwargs = qis.update_kwargs(kwargs=kwargs, new_kwargs=dict(legend_loc=None, is_unit_based_traded_volume=is_unit_based_traded_volume))
             portfolio_data.plot_performance_attribution(time_period=time_period,
                                                         attribution_metric=qis.AttributionMetric.COSTS,
                                                         ax=fig.add_subplot(gs[6, :2]),

{qis-3.0.2 → qis-3.0.4}/qis/utils/np_ops.py

@@ -249,14 +249,13 @@ def to_finite_ratio(x: Union[pd.Series, pd.DataFrame, np.ndarray],
     return x_y
 
 
-@njit
-def covar_to_corr(covar: np.ndarray) -> np.ndarray:
+def covar_to_corr(covar: Union[np.ndarray, pd.DataFrame]) -> Union[np.ndarray, pd.DataFrame]:
     """
     compute correlation out of covariance
     """
     inv_vol = np.reciprocal(np.sqrt(np.diag(covar)))
     norm = np.outer(inv_vol, inv_vol)
-    covar *= norm
+    covar = covar.multiply(norm)
     return covar