qis 3.1.5__tar.gz → 3.1.6__tar.gz

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

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

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

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

@@ -606,6 +606,7 @@ def compute_ewm_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
                     ) -> Union[pd.DataFrame, pd.Series, np.ndarray]:
     """
     implementation of ewm recursion for variance/volatility computation
+    vol_floor_quantile_roll_period will replace ewma estimate with quantile vol if vol < quantile vol
     """
     a = npo.to_finite_np(data=data, fill_value=np.nan)
 
@@ -634,7 +635,9 @@ def compute_ewm_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
     # apply quantile
     if vol_floor_quantile is not None:
         ewm_pd = pd.DataFrame(ewm)
-        ewm_quantiles = ewm_pd.rolling(vol_floor_quantile_roll_period, min_periods=100).quantile(vol_floor_quantile, interpolation="lower")
+        ewm_quantiles = ewm_pd.rolling(vol_floor_quantile_roll_period,
+                                       min_periods=int(0.2*vol_floor_quantile_roll_period)
+                                       ).quantile(vol_floor_quantile, interpolation="lower")
         vol_floor = ewm_quantiles.to_numpy()
         ewm = np.where(np.less(ewm, vol_floor), vol_floor, ewm)
 
@@ -657,7 +660,86 @@ def compute_ewm_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
         ewm = pd.DataFrame(data=ewm, index=data.index, columns=data.columns)
     elif isinstance(data, pd.Series):
         ewm = pd.Series(data=ewm, index=data.index, name=data.name)
+    return ewm
+
+
+def compute_ewm_newey_west_vol(data: Union[pd.DataFrame, pd.Series, np.ndarray],
+                               num_lags: int = 3,
+                               span: Optional[Union[float, np.ndarray]] = None,
+                               ewm_lambda: Union[float, np.ndarray] = 0.94,
+                               mean_adj_type: MeanAdjType = MeanAdjType.NONE,
+                               init_type: InitType = InitType.X0,
+                               init_value: Optional[Union[float, np.ndarray]] = None,
+                               apply_sqrt: bool = True,
+                               annualize: bool = False,
+                               af: Optional[float] = None,
+                               warmup_period: Optional[int] = None,
+                               nan_backfill: NanBackfill = NanBackfill.FFILL
+                               ) -> Union[pd.DataFrame, pd.Series, np.ndarray]:
+    """
+    implementation of newey west vol estimator
+    implementation of ewm recursion for variance/volatility computation
+    vol_floor_quantile_roll_period will replace ewma estimate with quantile vol if vol < quantile vol
+    """
+    a = npo.to_finite_np(data=data, fill_value=np.nan)
+
+    if span is not None:
+        ewm_lambda = 1.0 - 2.0 / (span + 1.0)
+
+    if mean_adj_type != MeanAdjType.NONE:
+        a = compute_rolling_mean_adj(data=a,
+                                     mean_adj_type=mean_adj_type,
+                                     ewm_lambda=ewm_lambda,
+                                     init_type=init_type,
+                                     nan_backfill=nan_backfill)
+
+    # initial conditions
+    a = a
+    if init_value is None:
+        init_value = set_init_dim1(data=a, init_type=init_type)
+
+    if isinstance(data, pd.Series) or (isinstance(data, np.ndarray) and data.ndim == 1):
+        ewm_lambda = float(ewm_lambda)
+        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)
+
+
+    # compute m recursions:
+    ewms = {}
+    for m in np.arange(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_
+
+
+    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 isinstance(data, pd.DataFrame) or isinstance(data, pd.Series):
+                af = 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
 
+    if apply_sqrt:
+        ewm = np.sqrt(ewm)
+
+    if isinstance(data, pd.DataFrame):
+        ewm = pd.DataFrame(data=ewm, index=data.index, columns=data.columns)
+    elif isinstance(data, pd.Series):
+        ewm = pd.Series(data=ewm, index=data.index, name=data.name)
     return ewm
 
 

{qis-3.1.5 → qis-3.1.6}/qis/utils/__init__.py

@@ -111,7 +111,7 @@ from qis.utils.df_ops import (
     get_first_nonnan_values,
     get_last_nonnan_values,
     get_last_nonnan,
-    merge_on_column,
+    merge_dfs_on_column,
     compute_nans_zeros_ratio_after_first_non_nan,
     reindex_upto_last_nonnan,
     multiply_df_by_dt,

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

@@ -549,19 +549,21 @@ def df12_merge_with_tz(df1: pd.DataFrame,
     return dfs
 
 
-def merge_on_column(df1: pd.DataFrame,
-                    df2: pd.DataFrame,
-                    is_drop_y: bool = True
-                    ) -> pd.DataFrame:
-    """
-    merge on homogeneous column with preservation of indices and drop dublicated, _y columns
-    """
-    joint_data = pd.merge(left=df1, right=df2,
-                          left_index=True, right_index=True,
-                          suffixes=('', '_y'), how='inner')
-    if is_drop_y:
-        unique_columns = sop.merge_lists_unique(list1=df1.columns.to_list(), list2=df2.columns.to_list())
-        joint_data = joint_data[unique_columns]
+def merge_dfs_on_column(data_df: pd.DataFrame,
+                        index_df: pd.DataFrame,
+                        index_column_in_data_df: str = 'bbg_ticker'
+                        ) -> pd.DataFrame:
+    """
+    merge data_df with index_df using index_column_in_data_df
+    index_df
+    """
+    data_df.index.name = 'index1'  # rename index
+    index_df.index.name = 'index2'  # rename index
+    # align dfs by index_column_in_data_df
+    index_df_joint_data = index_df.reindex(index=data_df[index_column_in_data_df].to_list())
+    # merge aligned dfs with reset index
+    joint_data = pd.concat([data_df.reset_index(drop=False), index_df_joint_data.reset_index(drop=False)], axis=1)
+    joint_data = joint_data.set_index(data_df.index.name)
     return joint_data
 
 
@@ -588,6 +590,7 @@ class UnitTests(Enum):
     SCORES = 2
     NONNANINDEX = 3
     REINDEX_UPTO_LAST_NONAN = 4
+    MERGE_DFS_ON_COLUMNS = 5
 
 
 def run_unit_test(unit_test: UnitTests):
@@ -643,10 +646,27 @@ def run_unit_test(unit_test: UnitTests):
         post_filled_up_nan = reindex_upto_last_nonnan(ds=ds, index=dates1, method='ffill')
         print(post_filled_up_nan)
 
+    elif unit_test == UnitTests.MERGE_DFS_ON_COLUMNS:
+        data_entries = {'Bond1': pd.Series(['AAA', 100.00, 'A3'], index=['bbg_ticker', 'face', 'raiting']),
+                        'Bond2': pd.Series(['AA', 100.00, 'A2'], index=['bbg_ticker', 'face', 'raiting']),
+                        'Bond3': pd.Series(['A', 100.00, 'A1'], index=['bbg_ticker', 'face', 'raiting']),
+                        'Bond4': pd.Series(['BBB', 100.00, 'B3'], index=['bbg_ticker', 'face', 'raiting'])}
+        data_df = pd.DataFrame.from_dict(data_entries, orient='index')
+
+        index_df = {'A': pd.Series([95.0], index=['price']),
+                    'AA': pd.Series([99.0], index=['price']),
+                    'AAA': pd.Series([101.0], index=['price']),
+                    'B': pd.Series([90.0], index=['price'])}
+        index_df = pd.DataFrame.from_dict(index_df, orient='index')
+        print(data_df)
+        print(index_df)
+        df = merge_dfs_on_column(data_df=data_df, index_df=index_df)
+        print(df)
+
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.REINDEX_UPTO_LAST_NONAN
+    unit_test = UnitTests.MERGE_DFS_ON_COLUMNS
 
     is_run_all_tests = False
     if is_run_all_tests:

{qis-3.1.5 → qis-3.1.6}/qis/utils/np_ops.py

@@ -620,7 +620,7 @@ def run_unit_test(unit_test: UnitTests):
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.CUM_POWER
+    unit_test = UnitTests.SHIFT_TEST
 
     is_run_all_tests = False
     if is_run_all_tests: