qis 3.1.5__tar.gz → 3.2.1__tar.gz

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

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "qis"
-version = "3.1.5"
+version = "3.2.1"
 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.2.1}/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.5 → qis-3.2.1}/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.5 → qis-3.2.1}/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.5 → qis-3.2.1}/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.5 → qis-3.2.1}/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,
@@ -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,21 +635,23 @@ 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)
 
     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)
@@ -657,7 +660,78 @@ 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,
+                               annualization_factor: 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)
 
+    ewm = ewm_recursion(a=np.square(a), ewm_lambda=ewm_lambda, init_value=init_value, nan_backfill=nan_backfill)
+
+    # compute m recursions
+    for m in np.arange(1, num_lags):
+        # lagged value
+        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 annualization_factor is not None:
+        if annualization_factor is None:
+            if isinstance(data, pd.DataFrame) or isinstance(data, pd.Series):
+                annualization_factor = da.infer_an_from_data(data=data)
+            else:
+                warnings.warn(f"in compute_ewm  annualization_factor for np array default is 1")
+                annualization_factor = 1.0
+        ewm = annualization_factor * 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.2.1}/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.5 → qis-3.2.1}/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.5 → qis-3.2.1}/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.5 → qis-3.2.1}/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.5 → qis-3.2.1}/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.5 → qis-3.2.1}/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.5 → qis-3.2.1}/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.5 → qis-3.2.1}/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.2.1}/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.5 → qis-3.2.1}/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")
@@ -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:
+def merge_dfs_on_column(data_df: pd.DataFrame,
+                        index_df: pd.DataFrame,
+                        index_column_in_data_df: str = 'bbg_ticker'
+                        ) -> pd.DataFrame:
     """
-    merge on homogeneous column with preservation of indices and drop dublicated, _y columns
+    merge data_df with index_df using index_column_in_data_df
+    index_df
     """
-    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]
+    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.2.1}/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: