my-github-tests 0.1.0__tar.gz

my_github_tests-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: my-github-tests
+Version: 0.1.0
+Summary: my github tests
+Author-email: AA SS <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/ArturSepp/my_private_github
+Project-URL: Repository, https://github.com/ArturSepp/my_private_github
+Project-URL: Issues, https://github.com/ArturSepp/my_private_github/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# my_private_github
+repo for my private projects
+ISQ objectives and deliverables for 2025

my_github_tests-0.1.0/README.md

@@ -0,0 +1,3 @@
+# my_private_github
+repo for my private projects
+ISQ objectives and deliverables for 2025

my_github_tests-0.1.0/mac_portfolio_optimizer/__init__.py

@@ -0,0 +1,22 @@
+from mac_portfolio_optimizer.data.mac_universe import (SUB_ASSET_CLASS_DEFINITIONS,
+                                                       MacUniverseData,
+                                                       UniverseColumns,
+                                                       RISK_FACTORS, SaaPortfolio, TaaPortfolio,
+                                                       MacRangeConstraints,
+                                                       SaaRangeConstraints,
+                                                       AssetClasses,
+                                                       RiskModel)
+
+from mac_portfolio_optimizer.data.excel_loader import (load_mac_portfolio_universe,
+                                                       load_universe_returns_from_sheet_data)
+
+from mac_portfolio_optimizer.core.backtester_optimiser import (backtest_saa_taa_portfolios,
+                                                               backtest_saa_risk_budget_portfolio,
+                                                               range_backtest_lasso_portfolio_with_alphas,
+                                                               tre_range_backtest_lasso_portfolio_with_alphas)
+
+from mac_portfolio_optimizer.core.current_portfolio_optimiser import run_current_saa_portfolio, run_current_saa_taa_portfolios
+
+from mac_portfolio_optimizer.mac_prod.reporting import generate_report
+
+from mac_portfolio_optimizer.mac_prod.fetch_prod_specs import get_prod_covar_estimator, get_meta_params

my_github_tests-0.1.0/mac_portfolio_optimizer/core/backtester_optimiser.py

@@ -0,0 +1,295 @@
+"""
+implementation of optimisers for current portfolio and time series backtest
+"""
+# packages
+import pandas as pd
+import qis as qis
+from typing import Optional, Union, Tuple, Dict
+from optimalportfolios import (rolling_risk_budgeting,
+                               rolling_maximise_alpha_over_tre,
+                               CovarEstimator,
+                               compute_joint_alphas,
+                               AlphasData,
+                               Constraints,
+                               EstimatedRollingCovarData)
+
+from mac_portfolio_optimizer import MacUniverseData
+
+
+def backtest_benchmarked_taa_portfolio(benchmark_rolling_weights: pd.DataFrame,
+                                       taa_alphas: pd.DataFrame,
+                                       covar_dict: Dict[pd.Timestamp, pd.DataFrame],
+                                       joint_prices: pd.DataFrame,
+                                       taa_constraints: Constraints,
+                                       joint_rebalancing_freq: pd.Series,
+                                       time_period: qis.TimePeriod = qis.TimePeriod('31Dec2003', None),
+                                       is_apply_tre_utility_objective: bool = False
+                                       ) -> pd.DataFrame:
+    """
+    wrapper for TAA optimisation given benchmark weights and alphas solve tre constraint optimisation
+    covar_dict is computed covariance for joint assets
+    """
+    joint_assets = joint_prices.columns
+    # generate rebalancing indicators
+    taa_rebalancing_indicators = qis.create_rebalancing_indicators_from_freqs(rebalancing_freqs=joint_rebalancing_freq,
+                                                                              time_period=time_period,
+                                                                              tickers=joint_assets)
+    # align alphas
+    taa_alphas = taa_alphas.reindex(index=list(covar_dict.keys()), method='ffill').ffill()
+    alphas_joint = taa_alphas.reindex(columns=joint_assets).fillna(0.0)
+    # reindex at covar frequency and joint prices columns
+    benchmark_rolling_weights = benchmark_rolling_weights.reindex(index=list(covar_dict.keys()), method='ffill').ffill()
+    benchmark_rolling_weights = benchmark_rolling_weights.reindex(columns=joint_assets).fillna(0.0)
+    taa_rolling_weights = rolling_maximise_alpha_over_tre(prices=joint_prices,
+                                                          alphas=alphas_joint,
+                                                          constraints0=taa_constraints,
+                                                          benchmark_weights=benchmark_rolling_weights,
+                                                          covar_dict=covar_dict,
+                                                          time_period=time_period,
+                                                          rebalancing_indicators=taa_rebalancing_indicators,
+                                                          apply_total_to_good_ratio=False,
+                                                          is_apply_tre_utility_objective=is_apply_tre_utility_objective)
+    return taa_rolling_weights
+
+
+def backtest_saa_risk_budget_portfolio(universe_data: MacUniverseData,
+                                       covar_estimator: CovarEstimator = None,
+                                       saa_taa_covar: Dict[pd.Timestamp, pd.DataFrame] = None,
+                                       time_period: qis.TimePeriod = qis.TimePeriod('31Dec2003', None),
+                                       saa_rebalancing_freq: str = 'QE',
+                                       saa_constraints: Constraints = None,
+                                       management_fee: float = 0.0,
+                                       apply_unsmoothing_for_pe: bool = True,
+                                       **kwargs
+                                       ) -> Tuple[pd.DataFrame, qis.PortfolioData]:
+    """
+    implementation for computing saa risk budget portfolio
+    use QE or YE for saa_rebalancing_freq
+    saa_taa_covar can be passed or calculated on the fly
+    """
+    saa_rebalancing_schedule = qis.generate_dates_schedule(time_period=time_period, freq=saa_rebalancing_freq)
+    saa_risk_prices = universe_data.get_saa_prices(apply_unsmoothing_for_pe=apply_unsmoothing_for_pe)
+
+    if saa_taa_covar is not None:
+        saa_assets = universe_data.saa_prices.columns
+        saa_pd_covars = {}
+        for date in saa_rebalancing_schedule:
+            saa_pd_covars[date] = saa_taa_covar[date].loc[saa_assets, saa_assets]
+    else:
+        # it is important that returns frequency is saa_rebalancing_freq otherwise we cannot compute proper returns of PE and PD
+        # estimate covar at rebalancing schedule
+        if covar_estimator is None:
+            raise ValueError(f"must pass covar_estimator")
+        covar_estimator.rebalancing_freq = saa_rebalancing_freq
+        rolling_covar_data = covar_estimator.fit_rolling_covars(prices=saa_risk_prices,
+                                                                risk_factor_prices=universe_data.get_risk_factors(),
+                                                                time_period=time_period)
+        covar_dict = rolling_covar_data.y_covars
+        # set saa rebalancing freq
+        saa_pd_covars = {}
+        for date in saa_rebalancing_schedule:
+            saa_pd_covars[date] = covar_dict[date]
+
+    # generate rebalancing indicators
+    saa_rebalancing_indicators = qis.create_rebalancing_indicators_from_freqs(rebalancing_freqs=saa_rebalancing_freq,
+                                                                              time_period=time_period,
+                                                                              tickers=universe_data.saa_prices.columns.to_list())
+
+    if saa_constraints is None:
+        saa_constraints =  universe_data.get_saa_constraints()
+    saa_rolling_weights = rolling_risk_budgeting(prices=saa_risk_prices,
+                                                 time_period=time_period,
+                                                 covar_dict=saa_pd_covars,
+                                                 risk_budget=universe_data.get_saa_risk_budget(),
+                                                 constraints0=saa_constraints,
+                                                 rebalancing_indicators=saa_rebalancing_indicators,
+                                                 apply_total_to_good_ratio=False)  # nb
+
+    saa_portfolio_data = qis.backtest_model_portfolio(prices=universe_data.get_saa_prices(),
+                                                      weights=saa_rolling_weights,
+                                                      management_fee=management_fee,
+                                                      ticker='SAA')
+    saa_portfolio_data.covar_dict = saa_pd_covars
+    return saa_rolling_weights, saa_portfolio_data
+
+
+def backtest_saa_taa_portfolios(universe_data: MacUniverseData,
+                                covar_estimator: CovarEstimator,
+                                time_period: qis.TimePeriod = qis.TimePeriod('31Dec2003', None),
+                                is_joint_saa_taa_covar: bool = True,
+                                saa_rebalancing_freq: str = 'QE',
+                                global_tracking_err_vol_constraint: Optional[float] = None,
+                                group_tracking_err_vol_constraint: Optional[pd.Series] = None,
+                                global_max_turnover_constraint: Optional[float] = None,
+                                group_max_turnover_constraint: Optional[pd.Series] = None,
+                                management_fee: float = 0.0,
+                                is_saa_benchmark_for_betas: bool = False,
+                                rebalancing_costs: float = 0.0,
+                                apply_unsmoothing_for_pe: bool = True,
+                                ) -> Tuple[qis.MultiPortfolioData, AlphasData, EstimatedRollingCovarData]:
+    """
+    wrapper for computing saa portfolio and saa-benchmarked taa portfolio
+    """
+    # 1. estimate covar
+    taa_covar_data = covar_estimator.fit_rolling_covars(risk_factor_prices=universe_data.get_risk_factors(),
+                                                        prices=universe_data.get_joint_prices(apply_unsmoothing_for_pe=apply_unsmoothing_for_pe),
+                                                        time_period=time_period)
+    covar_dict = taa_covar_data.y_covars
+
+    if is_joint_saa_taa_covar:
+        saa_taa_covar = covar_dict
+    else:
+        saa_taa_covar = None
+
+    # 2. run saa
+    saa_rolling_weights, saa_portfolio_data = backtest_saa_risk_budget_portfolio(universe_data=universe_data,
+                                                                                 saa_taa_covar=saa_taa_covar,
+                                                                                 time_period=time_period,
+                                                                                 covar_estimator=covar_estimator,
+                                                                                 saa_rebalancing_freq=saa_rebalancing_freq,
+                                                                                 management_fee=management_fee,
+                                                                                 apply_unsmoothing_for_pe=apply_unsmoothing_for_pe)
+
+    # 3. compute alphas
+    if is_saa_benchmark_for_betas:
+        benchmark_price = saa_portfolio_data.get_portfolio_nav()
+    else:
+        benchmark_price = universe_data.benchmarks.iloc[:, 0]
+    group_data, _ = universe_data.get_joint_sub_ac_group_data()
+    group_data_alphas, _ = universe_data.get_joint_ac_group_data()
+    # compute alpha using reported prices
+    taa_prices = universe_data.get_taa_prices(apply_unsmoothing_for_pe=apply_unsmoothing_for_pe)
+    manager_alphas = compute_joint_alphas(prices=taa_prices,
+                                          benchmark_price=benchmark_price,
+                                          risk_factors_prices=universe_data.get_risk_factors(),
+                                          alpha_beta_type=universe_data.get_alpha_beta_type(),
+                                          rebalancing_freq=universe_data.get_joint_rebalancing_freqs(),
+                                          estimated_betas=taa_covar_data.asset_last_betas_t,
+                                          group_data_alphas=universe_data.get_taa_asset_class_data(is_merge_alts_with_equity=True),
+                                          return_annualisation_freq_dict=universe_data.return_annualisation_freq_dict)
+
+    # 4. run tre portfolio
+    taa_constraints = universe_data.get_taa_constraints(
+        global_tracking_err_vol_constraint=global_tracking_err_vol_constraint,
+        group_tracking_err_vol_constraint=group_tracking_err_vol_constraint,
+        global_max_turnover_constraint=global_max_turnover_constraint,
+        group_max_turnover_constraint=group_max_turnover_constraint)
+
+    taa_rolling_weights = backtest_benchmarked_taa_portfolio(benchmark_rolling_weights=saa_rolling_weights,
+                                                             taa_alphas=manager_alphas.alpha_scores,
+                                                             joint_prices=universe_data.get_joint_prices(),
+                                                             joint_rebalancing_freq=universe_data.get_joint_rebalancing_freqs(),
+                                                             covar_dict=covar_dict,
+                                                             time_period=time_period,
+                                                             taa_constraints=taa_constraints)
+    prices = universe_data.get_joint_prices()
+    taa_portfolio_data = qis.backtest_model_portfolio(prices=prices,
+                                                      weights=taa_rolling_weights,
+                                                      management_fee=management_fee,
+                                                      rebalancing_costs=rebalancing_costs,
+                                                      ticker='TAA')
+    multi_portfolio_data = qis.MultiPortfolioData(portfolio_datas=[taa_portfolio_data, saa_portfolio_data],
+                                                  benchmark_prices=universe_data.benchmarks,
+                                                  covar_dict=covar_dict)
+    group_data, group_order = universe_data.get_joint_sub_ac_group_data()
+    [x.set_group_data(group_data=group_data, group_order=group_order) for x in multi_portfolio_data.portfolio_datas]
+    return multi_portfolio_data, manager_alphas, taa_covar_data
+
+
+def range_backtest_lasso_portfolio_with_alphas(universe_data: MacUniverseData,
+                                               covar_estimator: CovarEstimator,
+                                               time_period: qis.TimePeriod = qis.TimePeriod('31Dec2003', None),
+                                               is_joint_saa_taa_covar: bool = True,
+                                               saa_rebalancing_freq: Union[str, pd.Series] = 'QE',
+                                               global_tracking_err_vol_constraint: Optional[float] = None,
+                                               group_tracking_err_vol_constraint: Optional[pd.Series] = None,
+                                               global_max_turnover_constraint: Optional[float] = None,
+                                               group_max_turnover_constraint: Optional[pd.Series] = None,
+                                               management_fee: float = 0.0,
+                                               is_saa_benchmark_for_betas: bool = False,
+                                               rebalancing_costs: float = 0.0,
+                                               ) -> (qis.MultiPortfolioData, qis.MultiPortfolioData):
+
+    spans = [24]  # span, squeeze_factor
+    # reg_lambdas = [1e-4, 1e-5, 1e-6, 1e-7, 1e-8]
+    reg_lambdas = [1e-3, 1e-4, 1e-5, 1e-6, 1e-7, 1e-8, 0.0]
+    # reg_lambdas = [5.0*1e-5, 5.0*1e-6, 5.0*1e-7]
+    # reg_lambdas = [5.0 * 1e-4, 1e-4, 5.0 * 1e-5, 1e-5, 5.0 * 1e-6, 1e-6]
+    squeeze_factors = [0.0]
+
+    saa_portfolio_datas = []
+    taa_portfolio_datas = []
+    for span in spans:
+        for squeeze_factor in squeeze_factors:
+            for reg_lambda in reg_lambdas:
+                ticker = f"span={span:0.0f}, lambda={reg_lambda:0.0e}, sqze={squeeze_factor:0.2f}"
+                covar_estimator.lasso_model.reg_lambda = reg_lambda
+                covar_estimator.lasso_model.span = span
+                covar_estimator.span_freq_dict = {'ME': span, 'QE': span / 4}
+                multi_portfolio_data, _, _ = backtest_saa_taa_portfolios(universe_data=universe_data,
+                                                                      time_period=time_period,
+                                                                      covar_estimator=covar_estimator,
+                                                                      is_joint_saa_taa_covar=is_joint_saa_taa_covar,
+                                                                      saa_rebalancing_freq=saa_rebalancing_freq,
+                                                                      is_saa_benchmark_for_betas=is_saa_benchmark_for_betas,
+                                                                      global_tracking_err_vol_constraint=global_tracking_err_vol_constraint,
+                                                                      group_tracking_err_vol_constraint=group_tracking_err_vol_constraint,
+                                                                      global_max_turnover_constraint=global_max_turnover_constraint,
+                                                                      group_max_turnover_constraint=group_max_turnover_constraint,
+                                                                      rebalancing_costs=rebalancing_costs,
+                                                                      management_fee=management_fee)
+                saa_portfolio_datas.append(multi_portfolio_data.portfolio_datas[1].set_ticker(ticker))
+                taa_portfolio_datas.append(multi_portfolio_data.portfolio_datas[0].set_ticker(ticker))
+
+    saa_multi_portfolio_data = qis.MultiPortfolioData(portfolio_datas=saa_portfolio_datas,
+                                                      benchmark_prices=universe_data.benchmarks.iloc[:, 0])
+    taa_multi_portfolio_data = qis.MultiPortfolioData(portfolio_datas=taa_portfolio_datas,
+                                                      benchmark_prices=universe_data.benchmarks.iloc[:, 0])
+    return saa_multi_portfolio_data, taa_multi_portfolio_data
+
+
+def tre_range_backtest_lasso_portfolio_with_alphas(universe_data: MacUniverseData,
+                                                   covar_estimator: CovarEstimator,
+                                                   time_period: qis.TimePeriod = qis.TimePeriod('31Dec2003', None),
+                                                   saa_rebalancing_freq: str = 'QE',
+                                                   management_fee: float = 0.0,
+                                                   is_saa_benchmark_for_betas: bool = False,
+                                                   rebalancing_costs: float = 0.0,
+                                                   is_grouped_constaints: bool = True
+                                                   ) -> (qis.MultiPortfolioData, qis.MultiPortfolioData):
+
+    tracking_err_vol_constraints = [0.025]
+    turnover_constraints = [0.125, 0.25, 0.5]
+
+    saa_portfolio_datas = []
+    taa_portfolio_datas = []
+    for tracking_err_vol_constraint in tracking_err_vol_constraints:
+        for turnover_constraint in turnover_constraints:
+            if is_grouped_constaints:
+                ticker = f"group_tre_vol={tracking_err_vol_constraint:0.2%}, turnover={turnover_constraint:0.2%}"
+                group_tracking_err_vol_constraint = universe_data.set_group_uniform_tracking_error_constraint(tracking_err_vol_constraint=tracking_err_vol_constraint)
+                global_tracking_err_vol_constraint = None
+            else:
+                ticker = f"global_tre_vol={tracking_err_vol_constraint:0.2%}, turnover={turnover_constraint:0.2%}"
+                global_tracking_err_vol_constraint = tracking_err_vol_constraint
+                group_tracking_err_vol_constraint = None
+
+            multi_portfolio_data, _, _ = backtest_saa_taa_portfolios(universe_data=universe_data,
+                                                                  time_period=time_period,
+                                                                  covar_estimator=covar_estimator,
+                                                                  saa_rebalancing_freq=saa_rebalancing_freq,
+                                                                  global_tracking_err_vol_constraint=global_tracking_err_vol_constraint,
+                                                                  group_tracking_err_vol_constraint=group_tracking_err_vol_constraint,
+                                                                  global_max_turnover_constraint=turnover_constraint,
+                                                                  group_max_turnover_constraint=None,
+                                                                  management_fee=management_fee,
+                                                                  is_saa_benchmark_for_betas=is_saa_benchmark_for_betas,
+                                                                  rebalancing_costs=rebalancing_costs)
+            saa_portfolio_datas.append(multi_portfolio_data.portfolio_datas[1].set_ticker(ticker))
+            taa_portfolio_datas.append(multi_portfolio_data.portfolio_datas[0].set_ticker(ticker))
+
+    saa_multi_portfolio_data = qis.MultiPortfolioData(portfolio_datas=saa_portfolio_datas,
+                                                      benchmark_prices=universe_data.benchmarks.iloc[:, 0])
+    taa_multi_portfolio_data = qis.MultiPortfolioData(portfolio_datas=taa_portfolio_datas,
+                                                      benchmark_prices=universe_data.benchmarks.iloc[:, 0])
+    return saa_multi_portfolio_data, taa_multi_portfolio_data

my_github_tests-0.1.0/mac_portfolio_optimizer/core/current_portfolio_optimiser.py

@@ -0,0 +1,279 @@
+"""
+optimisation engine for the current portfolio
+"""
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import qis as qis
+from dataclasses import dataclass
+from typing import Dict, Any, Tuple, Optional
+from optimalportfolios import (CovarEstimator,
+                               EstimatedCurrentCovarData,
+                               EstimatedRollingCovarData,
+                               wrapper_risk_budgeting,
+                               compute_joint_alphas,
+                               wrapper_maximise_alpha_over_tre)
+
+from mac_portfolio_optimizer import MacUniverseData, backtest_saa_risk_budget_portfolio
+
+
+@dataclass
+class SaaTaaPortfolios:
+    """
+    output of current saa and taa portfolios
+    """
+    saa_valuation_date: pd.Timestamp
+    taa_valuation_date: pd.Timestamp
+    taa_df: pd.DataFrame
+    taa_covar: pd.DataFrame
+    saa_df: pd.DataFrame
+    saa_covar: pd.DataFrame
+    universe_data: MacUniverseData
+    taa_rolling_covar_data: EstimatedRollingCovarData
+    saa_current_covar_data: Optional[EstimatedCurrentCovarData]
+
+    taa_corr: pd.DataFrame = None
+    saa_corr: pd.DataFrame = None
+
+    def __post_init__(self):
+        self.taa_corr = qis.covar_to_corr(covar=self.taa_covar)
+        self.saa_corr = qis.covar_to_corr(covar=self.saa_covar)
+
+    def get_output_dict(self,
+                        period_2y: qis.TimePeriod = qis.TimePeriod('31Dec2022', '31Dec2024'),
+                        period_5y: qis.TimePeriod = qis.TimePeriod('31Dec2019', '31Dec2024'),
+                        saa_kwargs: Dict[str, Any] = dict(perf_params=qis.PerfParams(freq='QE'), alpha_an_factor=4.0),
+                        taa_kwargs: Dict[str, Any] = dict(perf_params=qis.PerfParams(freq='QE'), alpha_an_factor=4.0)
+                        ) -> Dict[str, pd.DataFrame]:
+        """
+        produce outputs dfs
+        """
+        taa_df = self.taa_df.copy()
+        saa_df = self.saa_df.copy()
+
+        saa_prices = pd.concat([self.universe_data.benchmarks, self.universe_data.saa_prices], axis=1)
+        saa_perf_2y = qis.get_ra_perf_benchmark_columns(prices=period_2y.locate(saa_prices),
+                                                        benchmark=self.universe_data.benchmarks.columns[0],
+                                                        is_convert_to_str=False,
+                                                        **saa_kwargs)
+        saa_perf_5y = qis.get_ra_perf_benchmark_columns(prices=period_5y.locate(saa_prices),
+                                                        benchmark=self.universe_data.benchmarks.columns[0],
+                                                        is_convert_to_str=False,
+                                                        **saa_kwargs)
+
+        taa_prices = pd.concat([self.universe_data.benchmarks, self.universe_data.taa_prices], axis=1)
+        taa_perf_2y = qis.get_ra_perf_benchmark_columns(prices=period_2y.locate(taa_prices),
+                                                        benchmark=self.universe_data.benchmarks.columns[0],
+                                                        is_convert_to_str=False,
+                                                        **taa_kwargs)
+        taa_perf_5y = qis.get_ra_perf_benchmark_columns(prices=period_5y.locate(taa_prices),
+                                                        benchmark=self.universe_data.benchmarks.columns[0],
+                                                        is_convert_to_str=False,
+                                                        **taa_kwargs)
+
+        # betas
+        taa_betas = self.taa_rolling_covar_data.asset_last_betas_t[self.taa_valuation_date].T.loc[taa_df.index]
+        saa_betas = self.taa_rolling_covar_data.asset_last_betas_t[self.saa_valuation_date].T.loc[saa_df.index]
+
+        # taa r2
+        taa_df['r2'] = self.taa_rolling_covar_data.r2_pd[taa_df.index].iloc[-1, :]
+
+        # add betas
+        taa_df = pd.concat([taa_df, taa_betas], axis=1)
+
+        # taa vols
+        ewma_vol = qis.compute_ewm_vol(data=qis.to_returns(prices=taa_prices, is_log_returns=True),
+                                       mean_adj_type=qis.MeanAdjType.EWMA, span=24, annualization_factor=12)
+        taa_df['lasso-vol'] = np.sqrt(np.diag(self.taa_covar))  # todo
+        taa_df['ewm-vol'] = ewma_vol.iloc[-1, :]
+        taa_df['vol 2y'] = taa_perf_2y['Vol'].loc[taa_df.index]
+
+        # merge with universe taa data
+        taa_universe_df = self.universe_data.taa_universe_df.copy()
+        if 'Current Max' in taa_universe_df.columns:  # remove level 2 attributions
+            col_index = taa_universe_df.columns.get_loc('Current Max')
+            columns_to_keep = taa_universe_df.columns[:col_index + 1]
+            taa_universe_df = taa_universe_df[columns_to_keep]
+
+        taa_df = pd.concat([taa_universe_df, taa_df, ], axis=1)
+        # saa r2 and vols
+        saa_df['r2'] = self.taa_rolling_covar_data.r2_pd[saa_df.index].iloc[-1, :]
+        saa_df['lasso-vol'] = np.sqrt(np.diag(self.saa_covar))
+        saa_df['vol 5y'] = saa_perf_5y['Vol'].loc[saa_df.index]
+
+        data = dict(taa_df=taa_df,
+                    saa_df=saa_df,
+                    taa_perf_2y=taa_perf_2y,
+                    taa_perf_5y=taa_perf_5y,
+                    saa_perf_2y=saa_perf_2y,
+                    saa_perf_5y=saa_perf_5y,
+                    taa_corr=self.taa_corr,
+                    saa_corr=self.saa_corr,
+                    taa_betas=taa_betas,
+                    saa_betas=saa_betas)
+        return data
+
+    def plot_taa_corr(self, **kwargs) -> plt.Subplot:
+        df = self.taa_corr
+        with sns.axes_style('darkgrid'):
+            width, height = qis.get_df_table_size(df=df)
+            fig, ax = plt.subplots(1, 1, figsize=(width, width), constrained_layout=True)
+            qis.plot_heatmap(df=df,
+                             var_format='{:.2f}',
+                             cmap='PiYG',
+                             ax=ax,
+                             **kwargs)
+        return fig
+
+
+def run_current_saa_portfolio(universe_data: MacUniverseData,
+                              covar_estimator: CovarEstimator,
+                              saa_pd_covar: pd.DataFrame = None,
+                              saa_valuation_date: pd.Timestamp = pd.Timestamp('31Dec2024'),
+                              saa_rebalancing_indicators: pd.Series = None  # for PE
+                              ) -> Tuple[pd.DataFrame, pd.DataFrame, Optional[EstimatedCurrentCovarData]]:
+    """
+    use QE or YE for saa_rebalancing_freq
+    """
+    if saa_pd_covar is None:
+        saa_covar_data = covar_estimator.fit_current_covars(
+            risk_factor_prices=universe_data.get_risk_factors().loc[:saa_valuation_date, :],
+            prices=universe_data.get_joint_prices().loc[:saa_valuation_date, :])
+        saa_pd_covar = saa_covar_data.y_covar
+    else:
+        saa_covar_data = None
+
+    saa_outputs = wrapper_risk_budgeting(pd_covar=saa_pd_covar,
+                                         constraints0=universe_data.get_saa_constraints(),
+                                         weights_0=None,
+                                         risk_budget=universe_data.get_saa_risk_budget(),
+                                         rebalancing_indicators=saa_rebalancing_indicators,
+                                         apply_total_to_good_ratio=False,
+                                         detailed_output=True)
+    return saa_outputs, saa_pd_covar, saa_covar_data
+
+
+def run_current_saa_taa_portfolios(universe_data: MacUniverseData,
+                                   covar_estimator: CovarEstimator,
+                                   saa_valuation_date: pd.Timestamp = pd.Timestamp('31Dec2024'),
+                                   taa_valuation_date: pd.Timestamp = pd.Timestamp('28Feb2024'),
+                                   time_period: qis.TimePeriod = qis.TimePeriod('31Dec2003', None),
+                                   saa_rebalancing_freq: str = 'QE',
+                                   taa_weights_0: pd.Series = None,
+                                   is_joint_saa_taa_covar: bool = True,
+                                   taa_rebalancing_indicators: pd.Series = None,
+                                   global_tracking_err_vol_constraint: Optional[float] = None,
+                                   group_tracking_err_vol_constraint: Optional[pd.Series] = None,
+                                   global_max_turnover_constraint: float = None,
+                                   group_max_turnover_constraint: Optional[pd.Series] = None,
+                                   is_saa_benchmark_for_betas: bool = True,
+                                   use_current_min_max: bool = True
+                                   ) -> SaaTaaPortfolios:
+    """
+    optimisation of the current saa_taa portfolio
+    taa_weights_0 are provided in universe_data
+    taa_weights_0 = universe_data.get_taa_current_weights()
+    """
+    # 1. estimate rolling covar for taa and betas
+    # we need betas time series to estiate alphas
+    risk_factor_prices = universe_data.get_risk_factors().loc[:taa_valuation_date, :]
+    taa_rolling_covar_data = covar_estimator.fit_rolling_covars(risk_factor_prices=risk_factor_prices,
+                                                                prices=universe_data.get_joint_prices().loc[:taa_valuation_date, :],
+                                                                time_period=time_period)
+    if is_joint_saa_taa_covar:
+        saa_taa_covar = taa_rolling_covar_data.y_covars
+        if saa_valuation_date not in saa_taa_covar.keys():
+            raise KeyError(f"{saa_valuation_date} not in {saa_taa_covar.keys()}")
+        saa_assets = universe_data.saa_prices.columns
+        saa_pd_covar = saa_taa_covar[saa_valuation_date].loc[saa_assets, saa_assets]
+    else:
+        raise NotImplementedError
+
+    # construct saa portfolio: we need saa portfolio weights for benchmark calculation and low beta characteristics
+    saa_rebalancing_indicators = qis.create_rebalancing_indicators_from_freqs(rebalancing_freqs=saa_rebalancing_freq,
+                                                                              time_period=time_period,
+                                                                              tickers=universe_data.saa_prices.columns.to_list())
+    saa_rolling_weights, saa_portfolio_data = backtest_saa_risk_budget_portfolio(universe_data=universe_data,
+                                                                                 saa_taa_covar=saa_taa_covar,
+                                                                                 time_period=time_period,
+                                                                                 covar_estimator=covar_estimator,
+                                                                                 saa_rebalancing_freq=saa_rebalancing_freq,
+                                                                                 management_fee=0.0)
+    # to do: use saa_rolling_weights
+    saa_df, saa_pd_covar, saa_current_covar_data = run_current_saa_portfolio(universe_data=universe_data,
+                                                                             covar_estimator=covar_estimator,
+                                                                             saa_pd_covar=saa_pd_covar,
+                                                                             saa_valuation_date=saa_valuation_date,
+                                                                             saa_rebalancing_indicators=saa_rebalancing_indicators.loc[saa_valuation_date, :])
+    rebalancing_freq = universe_data.get_joint_rebalancing_freqs()
+
+    current_saa_weights = saa_df['weights']
+    saa_df = saa_df.rename({'weights': 'SAA weight'}, axis=1)
+
+    # 2. compute alphas
+    if is_saa_benchmark_for_betas:
+        benchmark_price = saa_portfolio_data.get_portfolio_nav()
+    else:
+        benchmark_price = universe_data.benchmarks.iloc[:, 0]
+
+    joint_alphas = compute_joint_alphas(prices=universe_data.taa_prices,
+                                        benchmark_price=benchmark_price,
+                                        risk_factors_prices=universe_data.get_risk_factors(),
+                                        alpha_beta_type=universe_data.get_alpha_beta_type(),
+                                        rebalancing_freq=rebalancing_freq,
+                                        estimated_betas=taa_rolling_covar_data.asset_last_betas_t,
+                                        group_data_alphas=universe_data.get_taa_asset_class_data(is_merge_alts_with_equity=True),
+                                        return_annualisation_freq_dict=universe_data.return_annualisation_freq_dict)
+
+    # 3. run tre portfolio
+    if taa_weights_0 is None:
+        taa_weights_0 = universe_data.get_taa_current_weights()
+    taa_constraints = universe_data.get_taa_constraints(use_current_min_max=use_current_min_max,
+                                                        global_tracking_err_vol_constraint=global_tracking_err_vol_constraint,
+                                                        group_tracking_err_vol_constraint=group_tracking_err_vol_constraint,
+                                                        global_max_turnover_constraint=global_max_turnover_constraint,
+                                                        group_max_turnover_constraint=group_max_turnover_constraint)
+
+    # extend alphas and weights
+    taa_assets = universe_data.taa_prices.columns.to_list()
+    taa_covar = taa_rolling_covar_data.y_covars[taa_valuation_date].loc[taa_assets, taa_assets]
+    if taa_rebalancing_indicators is not None:
+        rebalancing_indicators = taa_rebalancing_indicators.reindex(index=taa_assets).fillna(0)
+    else:
+        rebalancing_indicators = pd.Series(1, index=taa_assets)
+    current_taa_weights = wrapper_maximise_alpha_over_tre(pd_covar=taa_covar,
+                                                          alphas=joint_alphas.alpha_scores.loc[taa_valuation_date, :],
+                                                          constraints0=taa_constraints,
+                                                          benchmark_weights=current_saa_weights,
+                                                          weights_0=taa_weights_0,
+                                                          rebalancing_indicators=rebalancing_indicators,
+                                                          apply_total_to_good_ratio=False,
+                                                          detailed_output=True)
+
+    taa_weights = current_taa_weights['weights'].loc[taa_assets].rename('Taa Weights')
+    # do few round rounding to converge to weights with 2 decimals
+    for n in np.arange(5):
+        taa_weights = taa_weights / np.nansum(taa_weights)
+        taa_weights = taa_weights.round(decimals=4)
+
+    if taa_weights_0 is not None:
+        taa_weights0 = taa_weights_0.loc[universe_data.taa_prices.columns].rename('Given Taa Weights')
+    else:
+        taa_weights0 = pd.Series(0.0, index=universe_data.taa_prices.columns).rename('Given Taa Weights')
+
+    taa_rebalancing_indicator = rebalancing_indicators.rename('Is Rebalanced')
+    delta = taa_weights.subtract(taa_weights0).rename('Delta weights')
+    alphas = joint_alphas.get_alphas_snapshot(date=taa_valuation_date)
+    risk_contribs = current_taa_weights['asset_rc_ratio'].loc[taa_assets].rename('Risk Contribution')
+    taa_df = pd.concat([taa_rebalancing_indicator, taa_weights0, taa_weights, delta, risk_contribs, alphas], axis=1)
+    saa_taa_portfolios = SaaTaaPortfolios(saa_valuation_date=saa_valuation_date,
+                                          taa_valuation_date=taa_valuation_date,
+                                          taa_df=taa_df,
+                                          saa_df=saa_df,
+                                          taa_covar=taa_covar,
+                                          saa_covar=saa_pd_covar,
+                                          universe_data=universe_data,
+                                          taa_rolling_covar_data=taa_rolling_covar_data,
+                                          saa_current_covar_data=saa_current_covar_data)
+    return saa_taa_portfolios