qis 3.1.6__tar.gz → 3.2.2__tar.gz

{qis-3.1.6 → qis-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qis
-Version: 3.1.6
+Version: 3.2.2
 Summary: Implementation of visualisation and reporting analytics for Quantitative Investment Strategies
 License: LICENSE.txt
 Keywords: quantitative,investing,portfolio optimization,systematic strategies,volatility

{qis-3.1.6 → qis-3.2.2}/pyproject.toml

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

{qis-3.1.6 → qis-3.2.2}/qis/examples/bootstrap_analysis.py

@@ -52,7 +52,7 @@ def plot_bootsrap_paths(prices: pd.Series,
     span = np.maximum(block_size, 5)
     ewma_vols = qis.compute_ewm_vol(data=log_returns,
                                     span=span,
-                                    af=252)
+                                    annualization_factor=252)
     with sns.axes_style("darkgrid"):
         fig, ax = plt.subplots(1, 1, figsize=(10, 7))
         qis.set_suptitle(fig, title=f"EWMA-{span} span volatility of realized (red) and bootsrapped paths (gray)")

{qis-3.1.6 → qis-3.2.2}/qis/examples/ohlc_vol_analysis.py

@@ -49,7 +49,7 @@ def fetch_hf_ohlc(ticker: str = 'SPY',
 
 def estimate_hf_vol(ticker: str = 'SPY',
                     agg_freq: str = 'B',
-                    af: float = 260,
+                    annualization_factor: float = 260,
                     freqs: List[str] = ['1d', '1h', '30m', '15m', '5m'],
                     ohlc_estimator_type: OhlcEstimatorType = OhlcEstimatorType.PARKINSON
                     ) -> pd.DataFrame:
@@ -60,20 +60,20 @@ def estimate_hf_vol(ticker: str = 'SPY',
         vols[freq] = qis.estimate_hf_ohlc_vol(ohlc_data=ohlc_data,
                                               ohlc_estimator_type=ohlc_estimator_type,
                                               agg_freq=agg_freq,
-                                              af=af*AF_MULTIPLIERS[freq])
+                                              annualization_factor=annualization_factor*AF_MULTIPLIERS[freq])
     vols = pd.DataFrame.from_dict(vols, orient='columns').dropna()
     return vols
 
 
 def plot_hf_vols(ticker: str = 'SPY',
                  agg_freq: str = 'B',
-                 af: float = 260,
+                 annualization_factor: float = 260,
                  freqs: List[str] = ['1d', '1h', '30m', '15m', '5m'],
                  ohlc_estimator_type: OhlcEstimatorType = OhlcEstimatorType.PARKINSON
                  ):
     vols = estimate_hf_vol(ticker=ticker,
                            agg_freq=agg_freq,
-                           af=af,
+                           annualization_factor=annualization_factor,
                            freqs=freqs,
                            ohlc_estimator_type=ohlc_estimator_type)
 
@@ -101,13 +101,13 @@ def run_unit_test(unit_test: UnitTests):
 
     elif unit_test == UnitTests.HF_VOL:
         # use small number of num_samples for illustration
-        df = estimate_hf_vol(ticker='SPY', agg_freq='B', af=260)
+        df = estimate_hf_vol(ticker='SPY', agg_freq='B', annualization_factor=260)
         print(df)
         df.plot()
 
     elif unit_test == UnitTests.PLOT_HF_VOL:
-        # plot_hf_vols(ticker='SPY', agg_freq='B', af=260)
-        plot_hf_vols(ticker='ETH-USD', agg_freq='D', af=365,
+        # plot_hf_vols(ticker='SPY', agg_freq='B', annualization_factor=260)
+        plot_hf_vols(ticker='ETH-USD', agg_freq='D', annualization_factor=365,
                      ohlc_estimator_type=OhlcEstimatorType.CLOSE_TO_CLOSE)
 
     plt.show()

{qis-3.1.6 → qis-3.2.2}/qis/examples/simulate_quant_strats.py

@@ -107,7 +107,7 @@ def plot_strategies_prices(nav_data: pd.DataFrame,
                            ) -> None:
 
     nav_returns = qis.to_returns(prices=nav_data)
-    eod_ewm_vol = qis.compute_ewm_vol(data=nav_returns, span=vol_span, mean_adj_type=qis.MeanAdjType.NONE, af=vol_af)
+    eod_ewm_vol = qis.compute_ewm_vol(data=nav_returns, span=vol_span, mean_adj_type=qis.MeanAdjType.NONE, annualization_factor=vol_af)
 
     # trim plot data
     nav_data = time_period.locate(nav_data)

{qis-3.1.6 → qis-3.2.2}/qis/examples/vol_without_weekends.py

@@ -30,10 +30,10 @@ def compute_vols(prices: pd.Series,
     """
     returns = np.log(prices).diff(1)
     init_value = np.nanvar(returns, axis=0)  # set initial value to average variance
-    vol = qis.compute_ewm_vol(data=returns, span=span, af=365*24, init_value=init_value)
+    vol = qis.compute_ewm_vol(data=returns, span=span, annualization_factor=365*24, init_value=init_value)
 
     returns1 = returns.where(returns.index.dayofweek < 5, other=np.nan)
-    vol1 = qis.compute_ewm_vol(data=returns1, span=span, af=260*24, init_value=init_value)
+    vol1 = qis.compute_ewm_vol(data=returns1, span=span, annualization_factor=260*24, init_value=init_value)
     vols = pd.concat([vol.rename('including weekends'),
                       vol1.rename('excluding weekends')], axis=1)
     return vols

{qis-3.1.6 → qis-3.2.2}/qis/models/__init__.py

@@ -41,6 +41,7 @@ from qis.models.linear.ewm import (
     compute_ewm_sharpe_from_prices,
     compute_ewm_std1_norm,
     compute_ewm_vol,
+    compute_ewm_newey_west_vol,
     compute_ewm_xy_beta_tensor,
     compute_one_factor_ewm_betas,
     compute_roll_mean,

{qis-3.1.6 → qis-3.2.2}/qis/models/linear/ewm.py

@@ -598,7 +598,7 @@ def compute_ewm_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
                     init_value: Optional[Union[float, np.ndarray]] = None,
                     apply_sqrt: bool = True,
                     annualize: bool = False,
-                    af: Optional[float] = None,
+                    annualization_factor: Optional[float] = None,
                     vol_floor_quantile: Optional[float] = None,  # to floor the volatility = 0.16
                     vol_floor_quantile_roll_period: int = 5*260,  # 5y for daily returns
                     warmup_period: Optional[int] = None,
@@ -644,14 +644,14 @@ def compute_ewm_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
     if warmup_period is not None:   # set to nan first nonnan in warmup_period
         ewm = npo.set_nans_for_warmup_period(a=ewm, warmup_period=warmup_period)
 
-    if annualize or af is not None:
-        if af is None:
+    if annualize or annualization_factor is not None:
+        if annualization_factor is None:
             if isinstance(data, pd.DataFrame) or isinstance(data, pd.Series):
-                af = da.infer_an_from_data(data=data)
+                annualization_factor = da.infer_an_from_data(data=data)
             else:
                 warnings.warn(f"in compute_ewm  annualization_factor for np array default is 1")
-                af = 1.0
-        ewm = af * ewm
+                annualization_factor = 1.0
+        ewm = annualization_factor * ewm
 
     if apply_sqrt:
         ewm = np.sqrt(ewm)
@@ -672,7 +672,7 @@ def compute_ewm_newey_west_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
                                init_value: Optional[Union[float, np.ndarray]] = None,
                                apply_sqrt: bool = True,
                                annualize: bool = False,
-                               af: Optional[float] = None,
+                               annualization_factor: Optional[float] = None,
                                warmup_period: Optional[int] = None,
                                nan_backfill: NanBackfill = NanBackfill.FFILL
                                ) -> Union[pd.DataFrame, pd.Series, np.ndarray]:
@@ -703,35 +703,27 @@ 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)
 
-    ewm0 = ewm_recursion(a=a, ewm_lambda=ewm_lambda, init_value=init_value, nan_backfill=nan_backfill)
+    ewm = ewm_recursion(a=np.square(a), ewm_lambda=ewm_lambda, init_value=init_value, nan_backfill=nan_backfill)
 
-
-    # compute m recursions:
-    ewms = {}
-    for m in np.arange(num_lags):
+    # compute m recursions
+    for m in np.arange(1, num_lags):
         # lagged value
-        if m == 0:
-            a_m = a
-        else:
-            a_m = np.empty_like(a)
-            a_m[m:] = a[:-m]
-            a_m[:m] = np.nan
-        ewms[m] = ewm_recursion(a=a*a_m, ewm_lambda=ewm_lambda, init_value=init_value, nan_backfill=nan_backfill)
-
-    ewm_
-
-
+        a_m = np.empty_like(a)
+        a_m[m:] = a[:-m]
+        a_m[:m] = np.nan
+        ewm_m = ewm_recursion(a=a*a_m, ewm_lambda=ewm_lambda, init_value=init_value, nan_backfill=nan_backfill)
+        ewm += (1.0-m/(num_lags+1))*ewm_m
     if warmup_period is not None:   # set to nan first nonnan in warmup_period
         ewm = npo.set_nans_for_warmup_period(a=ewm, warmup_period=warmup_period)
 
-    if annualize or af is not None:
-        if af is None:
+    if annualize or annualization_factor is not None:
+        if annualization_factor is None:
             if isinstance(data, pd.DataFrame) or isinstance(data, pd.Series):
-                af = da.infer_an_from_data(data=data)
+                annualization_factor = da.infer_an_from_data(data=data)
             else:
                 warnings.warn(f"in compute_ewm  annualization_factor for np array default is 1")
-                af = 1.0
-        ewm = af * ewm
+                annualization_factor = 1.0
+        ewm = annualization_factor * ewm
 
     if apply_sqrt:
         ewm = np.sqrt(ewm)

{qis-3.1.6 → qis-3.2.2}/qis/models/stats/ohlc_vol.py

@@ -56,7 +56,7 @@ def estimate_ohlc_var(ohlc_data: pd.DataFrame,  # must contain ohlc columnes
 
 def estimate_hf_ohlc_vol(ohlc_data: pd.DataFrame,
                          ohlc_estimator_type: OhlcEstimatorType = OhlcEstimatorType.PARKINSON,
-                         af: float = None,  # annualisation factor highly recomended
+                         annualization_factor: float = None,  # annualisation factor highly recomended
                          is_exclude_weekends: bool = False,  # for crypto
                          agg_freq: Optional[str] = 'B'
                          ) -> pd.Series:
@@ -69,10 +69,10 @@ def estimate_hf_ohlc_vol(ohlc_data: pd.DataFrame,
     if agg_freq is not None:
         sample_var = sample_var.resample(agg_freq).mean()
 
-    if af is None:
-        af = qis.infer_an_from_data(data=sample_var)
+    if annualization_factor is None:
+        annualization_factor = qis.infer_an_from_data(data=sample_var)
 
-    vols = np.sqrt(af*sample_var)
+    vols = np.sqrt(annualization_factor*sample_var)
     if is_exclude_weekends:
         vols = vols[vols.index.dayofweek < 5]
     return vols

{qis-3.1.6 → qis-3.2.2}/qis/perfstats/regime_classifier.py

@@ -41,7 +41,7 @@ def compute_regime_avg(sampled_returns_with_regime_id: pd.DataFrame,
 
     """
     compute conditional means by the regime ids
-    compute normalized prices attributions = af*freq*cvar
+    compute normalized prices attributions = annualization_factor*freq*cvar
     """
     # compute mean by regimes
     regime_means, norm_q = compute_mean_freq_regimes(sampled_returns_with_regime_id=sampled_returns_with_regime_id)

{qis-3.1.6 → qis-3.2.2}/qis/perfstats/timeseries_bfill.py

@@ -17,7 +17,7 @@ import qis.models.linear.ewm as ewm
 def interpolate_infrequent_returns(infrequent_returns: Union[pd.Series, pd.DataFrame],
                                    pivot_returns: pd.Series,
                                    span: int = 12,
-                                   af: float = 260,
+                                   annualization_factor: float = 260,
                                    is_to_log_returns: bool = False,
                                    vol_adjustment: float = 1.15  # adjust vol of the bridge
                                    ) -> Union[pd.Series, pd.DataFrame]:
@@ -32,7 +32,7 @@ def interpolate_infrequent_returns(infrequent_returns: Union[pd.Series, pd.DataF
             infrequent_return_backfills[column] = interpolate_infrequent_returns(infrequent_returns=ds,
                                                                                  pivot_returns=pivot_returns,
                                                                                  span=span,
-                                                                                 af=af,
+                                                                                 annualization_factor=annualization_factor,
                                                                                  is_to_log_returns=is_to_log_returns,
                                                                                  vol_adjustment=vol_adjustment)
         infrequent_return_backfills = pd.DataFrame.from_dict(infrequent_return_backfills, orient='columns')
@@ -55,7 +55,7 @@ def interpolate_infrequent_returns(infrequent_returns: Union[pd.Series, pd.DataF
     pivot_brownian = (pivot_brownian - np.nanmean(pivot_brownian)) / np.nanstd(pivot_brownian)  # path to (0, 1) brownian
 
     # add running times
-    seconds_per_year = af * 24 * 60 * 60  # days, hours, minute, seconds
+    seconds_per_year = annualization_factor * 24 * 60 * 60  # days, hours, minute, seconds
     t = pd.Series((infrequent_returns.index - date0).total_seconds() / seconds_per_year, index=infrequent_returns.index)
     t1 = t.shift(-1)
     dt = t1 - t

{qis-3.1.6 → qis-3.2.2}/qis/portfolio/ewm_portfolio_risk.py

@@ -25,15 +25,15 @@ VAR99_SCALER_BP = VAR99 * 10000
 def limit_weights_to_max_var_limit(weights: np.ndarray,
                                    vols: np.ndarray,
                                    max_var_limit_bp: Union[np.ndarray, float] = 25.00,
-                                   af: float = 260
+                                   annualization_factor: float = 260
                                    ) -> np.ndarray:
     """
     limit weights to max weight_max_var_bp
-    use: var = 2.33 * abs(weight) * vols_annualised / sqrt(af)
-    then abs(weight) <= weight_max_var_limit_bp / (VAR99_SCALER_BP * vols_annualised / sqrt(af))
+    use: var = 2.33 * abs(weight) * vols_annualised / sqrt(annualization_factor)
+    then abs(weight) <= weight_max_var_limit_bp / (VAR99_SCALER_BP * vols_annualised / sqrt(annualization_factor))
     vols are annualised vols
     """
-    saf = np.sqrt(af)
+    saf = np.sqrt(annualization_factor)
     instrument_var = VAR99_SCALER_BP * np.abs(weights) * vols / saf
     cond = instrument_var > max_var_limit_bp
     if np.any(cond):

{qis-3.1.6 → qis-3.2.2}/qis/portfolio/multi_portfolio_data.py

@@ -220,7 +220,7 @@ class MultiPortfolioData:
                                      benchmark_idx: int = 1,
                                      freq: Optional[str] = 'B',
                                      time_period: TimePeriod = None,
-                                     af: float = 260,
+                                     annualization_factor: float = 260,
                                      is_unit_based_traded_volume: bool = True,
                                      **kwargs
                                      ) -> pd.DataFrame:
@@ -266,10 +266,10 @@ class MultiPortfolioData:
 
         tre_table = pd.concat([total_diff, tre,
                                total_strategy_perf, total_benchmark_perf,
-                               af * strategy_turnover.mean(0).rename(f"{strategy_ticker} an turnover"),
-                               af * benchmark_turnover.mean(0).rename(f"{benchmark_ticker} an turnover"),
-                               af * strategy_cost.mean(0).rename(f"{strategy_ticker} an cost"),
-                               af * benchmark_cost.mean(0).rename(f"{benchmark_ticker} an cost"),
+                               annualization_factor * strategy_turnover.mean(0).rename(f"{strategy_ticker} an turnover"),
+                               annualization_factor * benchmark_turnover.mean(0).rename(f"{benchmark_ticker} an turnover"),
+                               annualization_factor * strategy_cost.mean(0).rename(f"{strategy_ticker} an cost"),
+                               annualization_factor * benchmark_cost.mean(0).rename(f"{benchmark_ticker} an cost"),
                                ], axis=1)
 
         return tre_table

{qis-3.1.6 → qis-3.2.2}/qis/portfolio/strats/quant_strats_delta1.py

@@ -24,7 +24,7 @@ def simulate_vol_target_strats(prices: Union[pd.DataFrame, pd.Series],
     ewm_vol = ewm.compute_ewm_vol(data=log_returns,
                                   span=vol_span,
                                   mean_adj_type=ewm.MeanAdjType.NONE,
-                                  af=vol_af)
+                                  annualization_factor=vol_af)
     # vol target weights
     weights_100 = qu.to_finite_reciprocal(data=ewm_vol, fill_value=0.0, is_gt_zero=True)
     nav_weights = weights_100.multiply(vol_target)

{qis-3.1.6 → qis-3.2.2}/qis/settings.yaml

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

{qis-3.1.6 → qis-3.2.2}/qis/utils/dates.py

@@ -46,12 +46,12 @@ def get_current_time_with_tz(tz: Optional[str] = 'UTC',
 def get_time_to_maturity(maturity_time: pd.Timestamp,
                          value_time: pd.Timestamp,
                          is_floor_at_zero: bool = True,
-                         af: float = 365
+                         annualization_factor: float = 365
                          ) -> float:
     """
     return annualised difference between mat_date and value_time
     """
-    seconds_per_year = af * 24 * 60 * 60  # days, hours, minute, seconds
+    seconds_per_year = annualization_factor * 24 * 60 * 60  # days, hours, minute, seconds
     ttm = (maturity_time - value_time).total_seconds() / seconds_per_year
     if is_floor_at_zero and ttm < 0.0:
         ttm = 0.0

{qis-3.1.6 → qis-3.2.2}/qis/utils/df_ops.py

@@ -312,7 +312,7 @@ def multiply_df_by_dt(df: Union[pd.DataFrame, pd.Series],
                       dates: Union[pd.DatetimeIndex, pd.Index] = None,
                       lag: Optional[int] = None,
                       is_actual_calendar_dt: bool = True,
-                      af: float = 365.0
+                      annualization_factor: float = 365.0
                       ) -> Union[pd.DataFrame, pd.Series]:
     """
     to compute rate adjustment with data - rate:
@@ -336,9 +336,9 @@ def multiply_df_by_dt(df: Union[pd.DataFrame, pd.Series],
     # apply dt multiplication
     if len(df.index) > 1:
         if is_actual_calendar_dt:
-            delta = np.append(0.0, (df.index[1:] - df.index[:-1]).days / af)
+            delta = np.append(0.0, (df.index[1:] - df.index[:-1]).days / annualization_factor)
         else:
-            delta = 1.0 / af
+            delta = 1.0 / annualization_factor
         df = df.multiply(delta, axis=0)
     else:
         warnings.warn(f"in adjust_data_with_dt: lengh of data index is one - cannot adjust by dt")