qis 3.0.3__tar.gz → 3.0.5__tar.gz

{qis-3.0.3 → qis-3.0.5}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "qis"
-version = "3.0.3"
+version = "3.0.5"
 description = "Implementation of visualisation and reporting analytics for Quantitative Investment Strategies"
 license = "LICENSE.txt"
 authors = ["Artur Sepp <artursepp@gmail.com>"]
@@ -50,6 +50,11 @@ pyarrow = ">=10.0.1"
 fsspec = ">=2022.11.0"
 yfinance = ">=0.1.38"
 
+#[build-system]
+#requires = ["poetry-core>=1.0.0"]
+#
+
 [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.3 → qis-3.0.5}/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.3 → qis-3.0.5}/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.3 → qis-3.0.5}/qis/portfolio/ewm_portfolio_risk.py

@@ -217,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.3 → qis-3.0.5}/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.3 → qis-3.0.5}/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

{qis-3.0.3 → qis-3.0.5}/qis/settings.yaml

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

{qis-3.0.3 → qis-3.0.5}/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