qis 3.2.4__tar.gz → 3.2.7__tar.gz

{qis-3.2.4 → qis-3.2.7}/PKG-INFO

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

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

{qis-3.2.4 → qis-3.2.7}/qis/models/__init__.py

@@ -47,7 +47,8 @@ from qis.models.linear.ewm import (
     compute_roll_mean,
     compute_rolling_mean_adj,
     set_init_dim1,
-    set_init_dim2
+    set_init_dim2,
+    compute_ewm_covar_newey_west
 )
 
 from qis.models.linear.ewm_convolution import ConvolutionType, SignalAggType, ewm_xy_convolution

{qis-3.2.4 → qis-3.2.7}/qis/models/linear/ewm.py

@@ -237,6 +237,7 @@ def compute_ewm_long_short_filter(data: Union[pd.DataFrame, pd.Series, np.ndarra
 
 @njit
 def compute_ewm_covar(a: np.ndarray,
+                      b: np.ndarray = None,
                       span: Union[int, np.ndarray] = None,
                       ewm_lambda: float = 0.94,
                       covar0: np.ndarray = None,
@@ -245,7 +246,13 @@ def compute_ewm_covar(a: np.ndarray,
                       ) -> np.ndarray:
     """
     compute ewm covariance matrix
+    b is optional, when given the covar is cross product a and b
     """
+    if b is None:
+        b = a
+    else:
+        assert a.shape[0] == b.shape[0]
+        assert a.shape[1] == b.shape[1]
 
     if span is not None:
         ewm_lambda = 1.0 - 2.0 / (span + 1.0)
@@ -263,7 +270,7 @@ def compute_ewm_covar(a: np.ndarray,
 
     last_covar = covar
     if a.ndim == 1:  # ndarry array
-        r_ij = np.outer(a, a)
+        r_ij = np.outer(a, b)
         covar = ewm_lambda_1 * r_ij + ewm_lambda * last_covar
         if nan_backfill == NanBackfill.FFILL:
             fill_value = last_covar
@@ -277,8 +284,7 @@ def compute_ewm_covar(a: np.ndarray,
     else:  # loop over rows
         t = a.shape[0]
         for idx in range(0, t):  # row in x:
-            row = a[idx]
-            r_ij = np.outer(row, row)
+            r_ij = np.outer(a[idx], b[idx])
             covar = ewm_lambda_1 * r_ij + ewm_lambda * last_covar
 
             if nan_backfill == NanBackfill.FFILL:
@@ -290,21 +296,59 @@ def compute_ewm_covar(a: np.ndarray,
 
             last_covar = np.where(np.isfinite(covar), covar, fill_value)
 
-            if is_corr:
-                if np.nansum(np.diag(last_covar)) > 1e-10:
-                    inv_vol = np.reciprocal(np.sqrt(np.diag(last_covar)))
-                    norm = np.outer(inv_vol, inv_vol)
-                else:
-                    norm = np.identity(n)
-                last_covar_ = norm * last_covar
+        # for covar normalise
+        if is_corr:
+            if np.nansum(np.diag(last_covar)) > 1e-10:
+                inv_vol = np.reciprocal(np.sqrt(np.diag(last_covar)))
+                norm = np.outer(inv_vol, inv_vol)
             else:
-                last_covar_ = last_covar
-
-            covar = last_covar_
+                norm = np.identity(n)
+            covar = norm * last_covar
+        else:
+            covar = last_covar
 
     return covar
 
 
+@njit
+def compute_ewm_covar_newey_west(a: np.ndarray,
+                                 num_lags: int = 2,
+                                 span: Union[int, np.ndarray] = None,
+                                 ewm_lambda: float = 0.94,
+                                 covar0: np.ndarray = None,
+                                 is_corr: bool = False,
+                                 nan_backfill: NanBackfill = NanBackfill.FFILL
+                                 ) -> np.ndarray:
+    """
+    implementation of newey west covar estimator
+    """
+    ewm0 = compute_ewm_covar(a=a, span=span, ewm_lambda=ewm_lambda, covar0=covar0, is_corr=False, nan_backfill=nan_backfill)
+    # compute m recursions
+    if num_lags > 0:
+        nw_adjustment = np.zeros_like(ewm0)
+        for m in np.arange(1, num_lags+1):
+            # lagged value
+            a_m = np.empty_like(a)
+            a_m[m:] = a[:-m]
+            a_m[:m] = np.nan
+            ewm_m1 = compute_ewm_covar(a=a, b=a_m, span=span)
+            # ewm_m2 = compute_ewm_covar(a=a_m, b=a, span=span)
+            nw_adjustment += (1.0-m/(num_lags+1))*(ewm_m1 + np.transpose(ewm_m1))
+        ewm_nw = ewm0 + nw_adjustment
+    else:
+        ewm_nw = ewm0
+
+    if is_corr:
+        if np.nansum(np.diag(ewm_nw)) > 1e-10:
+            inv_vol = np.reciprocal(np.sqrt(np.diag(ewm_nw)))
+            norm = np.outer(inv_vol, inv_vol)
+        else:
+            norm = np.identity(a.shape[1])
+        ewm_nw = norm * ewm_nw
+
+    return ewm_nw
+
+
 @njit
 def compute_ewm_covar_tensor(a: np.ndarray,
                              span: Union[int, np.ndarray] = None,
@@ -663,6 +707,27 @@ def compute_ewm_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
     return ewm
 
 
+@njit
+def matrix_recursion(a: np.ndarray,
+                     a_m: np.ndarray,
+                     span: Optional[Union[float, np.ndarray]] = None,
+                     ewm_lambda: Union[float, np.ndarray] = 0.94
+                     ) -> np.ndarray:
+    if span is not None:
+        ewm_lambda = 1.0 - 2.0 / (span + 1.0)
+    ewm_lambda_1 = 1.0 - ewm_lambda
+    t = a.shape[0]
+    last_covar = np.zeros((a.shape[1], a.shape[1]))
+    ewm_m = np.zeros_like(a_m)
+    for idx in range(0, t):
+        r_ij = np.outer(a[idx], a_m[idx])
+        covar = ewm_lambda_1 * r_ij + ewm_lambda * last_covar
+        fill_value = last_covar
+        last_covar = np.where(np.isfinite(covar), covar, fill_value)
+        ewm_m[idx, :] = np.diag(last_covar) + np.diag(np.transpose(last_covar))
+    return ewm_m
+
+
 def compute_ewm_newey_west_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
                                num_lags: int = 2,
                                span: Optional[Union[float, np.ndarray]] = None,
@@ -690,6 +755,7 @@ def compute_ewm_newey_west_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
     if mean_adj_type != MeanAdjType.NONE:
         a = compute_rolling_mean_adj(data=a,
                                      mean_adj_type=mean_adj_type,
+                                     span=span,
                                      ewm_lambda=ewm_lambda,
                                      init_type=init_type,
                                      nan_backfill=nan_backfill)
@@ -703,36 +769,25 @@ def compute_ewm_newey_west_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
         if isinstance(init_value, np.ndarray):
             init_value = float(init_value)
 
-    if span is not None:
-        ewm_lambda = 1.0 - 2.0 / (span + 1.0)
-    ewm_lambda_1 = 1.0 - ewm_lambda
-
-    def matrix_recursion(a_m: np.ndarray) -> np.ndarray:
-        t = a.shape[0]
-        last_covar = np.zeros((a.shape[1], a.shape[1]))
-        ewm_m = np.zeros_like(a_m)
-        for idx in range(0, t):
-            r_ij = np.outer(a[idx], a_m[idx])
-            covar = ewm_lambda_1 * r_ij + ewm_lambda * last_covar
-            fill_value = last_covar
-            last_covar = np.where(np.isfinite(covar), covar, fill_value)
-            ewm_m[idx, :] = np.diag(last_covar) + np.diag(np.transpose(last_covar))
-        return ewm_m
-
     ewm0 = ewm_recursion(a=np.square(a), ewm_lambda=ewm_lambda, init_value=init_value, nan_backfill=nan_backfill)
-    nw_adjustment = np.zeros_like(ewm0)
-    # compute m recursions
-    for m in np.arange(1, num_lags+1):
-        # lagged value
-        a_m = np.empty_like(a)
-        a_m[m:] = a[:-m]
-        a_m[:m] = np.nan
-        # qqq
-        ewm_m = matrix_recursion(a_m=a_m)
-        nw_adjustment += (1.0-m/(num_lags+1))*ewm_m
-
-    ewm_nw = ewm0 + nw_adjustment
-    nw_ratio = np.divide(ewm_nw, ewm0, where=ewm0 > 0.0)
+
+    if num_lags == 0:
+        ewm_nw = ewm0
+        nw_ratio = np.ones_like(ewm0)
+    else:
+        nw_adjustment = np.zeros_like(ewm0)
+        # compute m recursions
+        for m in np.arange(1, num_lags+1):
+            # lagged value
+            a_m = np.empty_like(a)
+            a_m[m:] = a[:-m]
+            a_m[:m] = np.nan
+            ewm_m = matrix_recursion(a=a, a_m=a_m, span=span)
+            nw_adjustment += (1.0-m/(num_lags+1))*ewm_m
+
+        ewm_nw = ewm0 + nw_adjustment
+        nw_ratio = np.divide(ewm_nw, ewm0, where=ewm0 > 0.0)
+        nw_ratio = np.where(nw_ratio > 0.0, nw_ratio, 1.0)
 
     if warmup_period is not None:   # set to nan first nonnan in warmup_period
         ewm_nw = npo.set_nans_for_warmup_period(a=ewm_nw, warmup_period=warmup_period)
@@ -819,7 +874,7 @@ def compute_rolling_mean_adj(data: Union[pd.DataFrame, pd.Series, np.ndarray],
                              mean_adj_type: MeanAdjType = MeanAdjType.EWMA,
                              span: Union[float, np.ndarray] = None,
                              ewm_lambda: Union[float, np.ndarray] = 0.94,
-                             init_type: InitType = InitType.MEAN,
+                             init_type: InitType = InitType.X0,
                              init_value: Union[float, np.ndarray, None] = None,
                              nan_backfill: NanBackfill = NanBackfill.FFILL
                              ) -> Union[pd.DataFrame, pd.Series, np.ndarray]:

{qis-3.2.4 → qis-3.2.7}/qis/plots/time_series.py

@@ -345,6 +345,7 @@ def plot_time_series_2ax(df1: Union[pd.Series, pd.DataFrame],
                      is_log=is_logs[0],
                      y_limits=y_limits,
                      ylabel=ylabel1,
+                     fontsize=fontsize,
                      ax=ax,
                      **kwargs)
 
@@ -358,16 +359,17 @@ def plot_time_series_2ax(df1: Union[pd.Series, pd.DataFrame],
                      is_log=is_logs[1],
                      y_limits=y_limits_ax2,
                      ylabel=ylabel2,
+                     fontsize=fontsize,
                      ax=ax_twin,
                      **kwargs)
 
+    ax.tick_params(axis='x', which='both', bottom=False)
+
     put.set_ax_ticks_format(ax=ax, fontsize=fontsize, xvar_format=None, yvar_format=var_format, set_ticks=False,
                             yvar_major_ticks=yvar_major_ticks1, x_rotation=x_rotation, **kwargs)
     put.set_ax_ticks_format(ax=ax_twin, fontsize=fontsize, xvar_format=None, yvar_format=var_format_yax2, set_ticks=False,
                             yvar_major_ticks=yvar_major_ticks2, x_rotation=x_rotation, **kwargs)
 
-    ax.tick_params(axis='x', which='both', bottom=False)
-
     if legend_loc is not None:
         if legend_labels is None:
             df1.columns = [f"{x} (left)" for x in df1.columns]

{qis-3.2.4 → qis-3.2.7}/qis/portfolio/reports/strategy_factsheet.py

@@ -20,6 +20,7 @@ def generate_strategy_factsheet(portfolio_data: PortfolioData,
                                 benchmark_prices: Union[pd.DataFrame, pd.Series],
                                 time_period: TimePeriod = None,
                                 ytd_attribution_time_period: TimePeriod = qis.get_ytd_time_period(),
+                                weight_report_time_period: TimePeriod = None,
                                 perf_params: PerfParams = PERF_PARAMS,
                                 regime_params: BenchmarkReturnsQuantileRegimeSpecs = REGIME_PARAMS,
                                 regime_benchmark: str = None,  # default is set to benchmark_prices.columns[0]
@@ -39,7 +40,6 @@ def generate_strategy_factsheet(portfolio_data: PortfolioData,
                                 figsize: Tuple[float, float] = (8.5, 11.7),  # A4 for portrait
                                 fontsize: int = 4,
                                 weight_change_sample_size: int = 20,
-                                weight_report_time_period: TimePeriod = None,
                                 add_current_position_var_risk_sheet: bool = False,
                                 add_weights_turnover_sheet: bool = False,
                                 add_grouped_exposures: bool = False,

{qis-3.2.4 → qis-3.2.7}/qis/settings.yaml

@@ -18,3 +18,4 @@ OUTPUT_PATH:
 
 AWS_POSTGRES:
   ""
+

qis-3.2.4/qis/examples/bond_futures_portfolio.py

@@ -1,49 +0,0 @@
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-from enum import Enum
-import qis as qis
-
-import futures_strats.local_path as lp
-
-output_path = lp.OUTPUT_PATH
-local_path = lp.LOCAL_PATH
-# futures_strats
-from futures_strats import (compute_strategy_portfolio_data_with_costs,
-                            compute_multi_strategy_data_from_blocks,
-                            compute_marginal_perfs_for_strategy)
-from futures_strats.data.universes.futures.bbg_futures import Universes
-from futures_strats.data.providers.bloomberg.assets_bbg import AssetsBBG
-from futures_strats.research.cross_trend import (CSTF_RB_TRACKER,
-                                                 CSTF_EXACT_TRACKER,
-                                                 CSTF_RB_AC_TRACKER)
-from futures_strats.research.trackers import (CSTF_GOLDMAN_TRACKER_AC,
-                                              GOLDMAN_UNIVERSE)
-
-strategy_universe = Universes.BBG_FUTURES_INVESTABLE.load_universe_data(local_path=local_path)
-prices = strategy_universe.get_prices(freq='B')[['UXY1 Comdty', 'US1 Comdty', 'WN1 Comdty']].ffill().dropna()
-prices = prices[prices.columns[::-1]]
-qis.plot_prices_with_dd(prices=prices)
-
-portfolio_data = qis.backtest_model_portfolio(prices=prices,
-                                              weights=np.array([-1.0, 2.0, -1.0]),
-                                              rebalancing_freq='ME',
-                                              ticker='Butterly'
-                                              )
-
-time_period = qis.TimePeriod('31Dec2015', None)
-figs = qis.generate_strategy_factsheet(portfolio_data=portfolio_data,
-                                       benchmark_prices=prices.iloc[:, -1],
-                                       is_grouped=False,
-                                       add_current_position_var_risk_sheet=False,
-                                       add_weights_turnover_sheet=False,
-                                       add_grouped_exposures=False,
-                                       add_grouped_cum_pnl=False,
-                                       time_period=time_period,
-                                       **qis.fetch_default_report_kwargs(time_period=time_period,
-                                                                         add_rates_data=False))
-
-qis.save_figs_to_pdf(figs=figs, file_name=f"butterfly", orientation='landscape',
-                     local_path=output_path)
-
-plt.show()

qis-3.2.4/qis/examples/credit_trackers.py

@@ -1,42 +0,0 @@
-
-import pandas as pd
-import matplotlib.pyplot as plt
-import seaborn as sns
-import qis as qis
-from bbg_fetch import fetch_field_timeseries_per_tickers
-
-
-tickers = {'CICMCE5B Index': 'ITRAXX Main 5Y',
-           'CICMCE1B Index': 'ITRAXX Main 10Y',
-           'CICMCX5B Index': 'ITRAXX Xover 5Y',
-           'CICMCI5B Index': 'CDX NA IG 5Y',
-           'CICMCI1B Index': 'CDX NA IG 10Y',
-           'CICMCH5B Index': 'CDX NA HY 5Y',
-           'CICMCG05 Index': 'UK CDS 5Y',
-           'CICMCK05 Index': 'South Korea CDS 5Y',
-           'CICMCJ05 Index': 'Japan CDS 5Y',
-           'CICMCU05 Index': 'US CDS 5Y',
-           'CICMCE05 Index': 'Germany CDS 5Y'
-           }
-
-tickers = {'UISYMH5S Index': 'UBS_CDX_HY',
-           'CICMCH5B Index': 'CITI_CDX_HY',
-           'CH5LMER5 Index': 'GS_CDX_HY',
-           'UISYMI5S Index': 'UBS_IG_5Y',
-           'CICMCI5B Index': 'CITI_IG_5Y',
-           'CI5LMER5 Index': 'GS_IG_5Y'}
-
-prices = fetch_field_timeseries_per_tickers(tickers=tickers, freq='B', field='PX_LAST').ffill()
-print(prices)
-benchmark_prices = fetch_field_timeseries_per_tickers(tickers={'LGDRTRUU Index': 'Agg IG'}, freq='B', field='PX_LAST').ffill()
-
-time_period = qis.TimePeriod('01Jan2008', pd.Timestamp.today())
-kwargs = qis.fetch_default_report_kwargs(time_period=time_period, add_rates_data=False)
-
-fig = qis.generate_multi_asset_factsheet(prices=prices,
-                                         benchmark_prices=benchmark_prices,
-                                         time_period=time_period,
-                                         **kwargs)
-qis.save_figs_to_pdf(figs=[fig],
-                     file_name=f"credit_trackers_report", orientation='landscape',
-                     local_path=qis.local_path.get_output_path())

qis-3.2.4/qis/examples/perp_pricing.py

@@ -1,56 +0,0 @@
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import seaborn as sns
-import qis as qis
-from bbg_fetch import fetch_field_timeseries_per_tickers, fetch_index_members_weights, fetch_bonds_info
-
-
-index_ticker = 'I31415US Index'
-
-end_dates = ['20180101', '20190101', '20200101', '20210101', '20220101', '20230101', '20240101', '20250101', '20250106']
-
-data_out = {}
-weighted_resets = []
-for idx, end_date in enumerate(end_dates):
-    if idx > 0:
-        members = fetch_index_members_weights(index_ticker, END_DATE_OVERRIDE=end_dates[idx-1])
-        corp_index = [f"{x} corp" for x in members.index]
-        members.index = corp_index
-        """
-        amt_outstanding = fetch_bonds_info(isins=members.index.to_list(), fields=['amt_outstanding'],
-                                           END_DATE_OVERRIDE=end_dates[idx-1])['amt_outstanding']
-        amt_outstanding = amt_outstanding.loc[members.index]
-        amt_outstanding.index = corp_index
-        """
-        prices = fetch_field_timeseries_per_tickers(tickers=corp_index,
-                                                    start_date=pd.Timestamp(end_dates[idx-1]),
-                                                    end_date=pd.Timestamp(end_date),
-                                                    freq='B')
-        prices = prices.resample('W-WED').last()
-        # market_value = prices.multiply(amt_outstanding, axis=1)
-        #market_value.divide(np.nansum(market_value, axis=1, keepdims=True), axis=1)
-        is_reset = (prices > 100).astype(float)
-        market_weights = members.iloc[:, 0]
-        weighted_reset = is_reset.multiply(market_weights, axis=1)
-        weighted_reset = weighted_reset.sum(1)
-        weighted_resets.append(weighted_reset)
-        data_out[f"{end_dates[idx-1]} members"] = members
-        data_out[f"{end_date} prices"] = prices
-        data_out[f"{end_date} is_reset"] = is_reset
-
-weighted_resets = pd.concat(weighted_resets)
-weighted_resets = weighted_resets.loc[~weighted_resets.index.duplicated(keep='first')]
-weighted_resets = weighted_resets.to_frame('weighted_par_reset %')
-print(weighted_resets)
-
-data_out['weighted_resets'] = weighted_resets
-qis.save_df_to_excel(data=data_out, file_name='perp_pricing')
-
-with sns.axes_style("darkgrid"):
-    fig, ax = plt.subplots(1, 1, figsize=(15, 8), tight_layout=True)
-    qis.plot_time_series(weighted_resets,
-                         title='weighted_par_reset',
-                         ax=ax)
-
-plt.show()