qis 3.0.5__tar.gz → 3.0.7__tar.gz

{qis-3.0.5 → qis-3.0.7}/PKG-INFO

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

{qis-3.0.5 → qis-3.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "qis"
-version = "3.0.5"
+version = "3.0.7"
 description = "Implementation of visualisation and reporting analytics for Quantitative Investment Strategies"
 license = "LICENSE.txt"
 authors = ["Artur Sepp <artursepp@gmail.com>"]
@@ -50,10 +50,6 @@ pyarrow = ">=10.0.1"
 fsspec = ">=2022.11.0"
 yfinance = ">=0.1.38"
 
-#[build-system]
-#requires = ["poetry-core>=1.0.0"]
-#
-
 [build-system]
 requires = ["poetry-core>=1.0.0", "hatchling==1.27.0", "hatch-vcs"]
 #build-backend = "hatchling.build"

{qis-3.0.5 → qis-3.0.7}/qis/examples/core/price_plots.py

@@ -28,7 +28,7 @@ RA_TABLE_COLUMNS = (PerfStat.START_DATE,
 
 
 def generate_performances(prices: pd.DataFrame,
-                          regime_benchmark_str: str,
+                          regime_benchmark: str,
                           perf_params: qis.PerfParams = None,
                           perf_columns: List[PerfStat] = RA_TABLE_COLUMNS,
                           heatmap_freq: str = 'YE',
@@ -43,7 +43,7 @@ def generate_performances(prices: pd.DataFrame,
     fig, ax = plt.subplots(1, 1, figsize=(12, 4), tight_layout=True)
 
     qis.plot_ra_perf_table_benchmark(prices=prices,
-                                     benchmark=regime_benchmark_str,
+                                     benchmark=regime_benchmark,
                                      perf_params=perf_params,
                                      perf_columns=perf_columns,
                                      title=f"Risk-adjusted performance: {qis.get_time_period_label(prices, date_separator='-')}",
@@ -61,7 +61,7 @@ def generate_performances(prices: pd.DataFrame,
     with sns.axes_style("darkgrid"):
         fig, ax = plt.subplots(1, 1, figsize=(8, 6))
         qis.plot_prices(prices=prices,
-                        regime_benchmark_str=regime_benchmark_str,
+                        regime_benchmark=regime_benchmark,
                         perf_params=perf_params,
                         title=f"Time series of $1 invested: {qis.get_time_period_label(prices, date_separator='-')}",
                         ax=ax,
@@ -69,7 +69,7 @@ def generate_performances(prices: pd.DataFrame,
 
         fig, axs = plt.subplots(2, 1, figsize=(7, 7))
         qis.plot_prices_with_dd(prices=prices,
-                                regime_benchmark_str=regime_benchmark_str,
+                                regime_benchmark=regime_benchmark,
                                 perf_params=perf_params,
                                 title=f"Time series of $1 invested: {qis.get_time_period_label(prices, date_separator='-')}",
                                 axs=axs,
@@ -77,7 +77,7 @@ def generate_performances(prices: pd.DataFrame,
 
         fig, ax = plt.subplots(1, 1, figsize=(8, 6))
         qis.plot_scatter_regression(prices=prices,
-                                    regime_benchmark_str=regime_benchmark_str,
+                                    regime_benchmark=regime_benchmark,
                                     regime_params=qis.BenchmarkReturnsQuantileRegimeSpecs(freq=perf_params.freq_reg),
                                     perf_params=perf_params,
                                     title=f"Regime Conditional Regression: {qis.get_time_period_label(prices, date_separator='-')}",
@@ -99,30 +99,30 @@ def run_unit_test(unit_test: UnitTests):
     ust_3m_rate = yf.download('^IRX', start=None, end=None)['Close'].dropna() / 100.0
 
     if unit_test == UnitTests.ETF_DATA:
-        regime_benchmark_str = 'SPY'
-        tickers = [regime_benchmark_str, 'QQQ', 'EEM', 'TLT', 'IEF', 'LQD', 'HYG', 'SHY', 'GLD']
+        regime_benchmark = 'SPY'
+        tickers = [regime_benchmark, 'QQQ', 'EEM', 'TLT', 'IEF', 'LQD', 'HYG', 'SHY', 'GLD']
 
     elif unit_test == UnitTests.CRYPTO_DATA:
-        regime_benchmark_str = 'BTC-USD'
-        tickers = [regime_benchmark_str, 'ETH-USD', 'SOL-USD']
-        regime_benchmark_str = 'BTC-USD'
-        tickers = [regime_benchmark_str, 'SPY', 'TLT', 'ETH-USD', 'SOL-USD']
+        regime_benchmark = 'BTC-USD'
+        tickers = [regime_benchmark, 'ETH-USD', 'SOL-USD']
+        regime_benchmark = 'BTC-USD'
+        tickers = [regime_benchmark, 'SPY', 'TLT', 'ETH-USD', 'SOL-USD']
 
     elif unit_test == UnitTests.TF_ETF:
-        regime_benchmark_str = 'SPY'
-        tickers = [regime_benchmark_str, 'DBMF', 'WTMF', 'CTA']
+        regime_benchmark = 'SPY'
+        tickers = [regime_benchmark, 'DBMF', 'WTMF', 'CTA']
 
     elif unit_test == UnitTests.ETFS:
-        regime_benchmark_str = 'AOR'
-        tickers = [regime_benchmark_str, 'SPY', 'PEX', 'PSP', 'GSG', 'COMT', 'REET', 'REZ']
+        regime_benchmark = 'AOR'
+        tickers = [regime_benchmark, 'SPY', 'PEX', 'PSP', 'GSG', 'COMT', 'REET', 'REZ']
 
     elif unit_test == UnitTests.COMMODITY_ETFS:
-        regime_benchmark_str = 'AOR'
-        tickers = [regime_benchmark_str, 'SPY', 'GLD', 'GSG', 'COMT', 'PDBC']
+        regime_benchmark = 'AOR'
+        tickers = [regime_benchmark, 'SPY', 'GLD', 'GSG', 'COMT', 'PDBC']
 
     elif unit_test == UnitTests.VOL_ETFS:
-        regime_benchmark_str = 'SPY'
-        tickers = [regime_benchmark_str, 'SVOL']
+        regime_benchmark = 'SPY'
+        tickers = [regime_benchmark, 'SVOL']
 
     else:
         raise NotImplementedError
@@ -146,7 +146,7 @@ def run_unit_test(unit_test: UnitTests):
         prices = time_period.locate(prices)
 
     generate_performances(prices=prices,
-                          regime_benchmark_str=regime_benchmark_str,
+                          regime_benchmark=regime_benchmark,
                           **kwargs)
 
     plt.show()

{qis-3.0.5 → qis-3.0.7}/qis/examples/factsheets/strategy_benchmark.py

@@ -17,7 +17,7 @@ from qis.portfolio.reports.config import fetch_default_report_kwargs
 from qis.portfolio.reports.strategy_benchmark_factsheet import (generate_strategy_benchmark_factsheet_plt,
                                                                 generate_strategy_benchmark_active_perf_plt,
                                                                 generate_performance_attribution_report,
-                                                                weights_tracking_error_report)
+                                                                weights_tracking_error_report_by_ac_subac)
 
 
 def fetch_universe_data() -> Tuple[pd.DataFrame, pd.DataFrame, pd.Series]:
@@ -34,7 +34,11 @@ def fetch_universe_data() -> Tuple[pd.DataFrame, pd.DataFrame, pd.Series]:
                          GLD='Gold')
     tickers = list(universe_data.keys())
     group_data = pd.Series(universe_data)  # for portfolio reporting
-    prices = yf.download(tickers=tickers, start=None, end=None, ignore_tz=True)['Close'][tickers]
+    # prices = yf.download(tickers=tickers, start=None, end=None, ignore_tz=True)['Close'][tickers]
+    from qis.test_data import load_etf_data
+    prices = load_etf_data()[tickers]
+    print(prices)
+
     prices = prices.asfreq('B', method='ffill')
     benchmark_prices = prices[['SPY', 'TLT']]
     return prices, benchmark_prices, group_data
@@ -87,6 +91,8 @@ def run_unit_test(unit_test: UnitTests):
     # time period for portfolio reporting
     time_period = qis.TimePeriod('31Dec2006', '10Jan2025')
     prices, benchmark_prices, group_data = fetch_universe_data()
+
+
     multi_portfolio_data = generate_volparity_multiportfolio(prices=prices,
                                                              benchmark_prices=benchmark_prices,
                                                              group_data=group_data,
@@ -137,8 +143,14 @@ def run_unit_test(unit_test: UnitTests):
                                                     rebalancing_freq='ME',
                                                     span=52)
         multi_portfolio_data.covar_dict = covar_dict
-        weights_tracking_error_report(multi_portfolio_data=multi_portfolio_data,
-                                      time_period=time_period)
+        ac_group_data = multi_portfolio_data.portfolio_datas[0].group_data
+        asset_tickers = multi_portfolio_data.portfolio_datas[0].weights.columns
+        sub_ac_group_data = pd.Series(asset_tickers, index=asset_tickers)
+
+        weights_tracking_error_report_by_ac_subac(multi_portfolio_data=multi_portfolio_data,
+                                                  ac_group_data=ac_group_data,
+                                                  sub_ac_group_data=sub_ac_group_data,
+                                                  time_period=time_period)
 
     plt.show()
 

{qis-3.0.5 → qis-3.0.7}/qis/examples/perf_external_assets.py

@@ -29,7 +29,7 @@ perf_params = qis.PerfParams(freq='ME', freq_reg='W-WED', alpha_an_factor=52.0,
 with sns.axes_style("darkgrid"):
     fig1, axs = plt.subplots(2, 1, figsize=(10, 7))
     qis.plot_prices_with_dd(prices=prices,
-                            regime_benchmark_str=benchmark,
+                            regime_benchmark=benchmark,
                             x_date_freq='QE',
                             framealpha=0.9,
                             perf_params=perf_params,

{qis-3.0.5 → qis-3.0.7}/qis/examples/try_pybloqs.py

@@ -37,7 +37,7 @@ RA_TABLE_COLUMNS = [#PerfStat.START_DATE,
 
 
 def generate_performances(prices: pd.DataFrame,
-                          regime_benchmark_str: str,
+                          regime_benchmark: str,
                           perf_params: qis.PerfParams = None,
                           heatmap_freq: str = 'YE',
                           **kwargs
@@ -78,7 +78,7 @@ def generate_performances(prices: pd.DataFrame,
     with sns.axes_style("darkgrid"):
         fig3, ax = plt.subplots(1, 1, figsize=(8, 6))
         qis.plot_prices(prices=prices,
-                        regime_benchmark_str=regime_benchmark_str,
+                        regime_benchmark=regime_benchmark,
                         perf_params=perf_params,
                         title=f"Time series of $1 invested: {qis.get_time_period_label(prices, date_separator='-')}",
                         ax=ax,
@@ -86,7 +86,7 @@ def generate_performances(prices: pd.DataFrame,
 
         fig4, axs = plt.subplots(2, 1, figsize=(7, 7))
         qis.plot_prices_with_dd(prices=prices,
-                                regime_benchmark_str=regime_benchmark_str,
+                                regime_benchmark=regime_benchmark,
                                 perf_params=perf_params,
                                 title=f"Time series of $1 invested: {qis.get_time_period_label(prices, date_separator='-')}",
                                 axs=axs,
@@ -94,7 +94,7 @@ def generate_performances(prices: pd.DataFrame,
 
         fig5, ax = plt.subplots(1, 1, figsize=(8, 6))
         qis.plot_scatter_regression(prices=prices,
-                                    regime_benchmark_str=regime_benchmark_str,
+                                    regime_benchmark=regime_benchmark,
                                     regime_params=qis.BenchmarkReturnsQuantileRegimeSpecs(freq=perf_params.freq_reg),
                                     perf_params=perf_params,
                                     title=f"Regime Conditional Regression: {qis.get_time_period_label(prices, date_separator='-')}",
@@ -134,12 +134,12 @@ def run_unit_test(unit_test: UnitTests):
     ust_3m_rate = yf.download('^IRX', start=None, end=None)['Close'].dropna() / 100.0
 
     if unit_test == UnitTests.ETF_DATA:
-        regime_benchmark_str = 'SPY'
-        tickers = [regime_benchmark_str, 'QQQ', 'EEM', 'TLT', 'IEF', 'LQD', 'HYG', 'SHY', 'GLD']
+        regime_benchmark = 'SPY'
+        tickers = [regime_benchmark, 'QQQ', 'EEM', 'TLT', 'IEF', 'LQD', 'HYG', 'SHY', 'GLD']
 
     elif unit_test == UnitTests.CRYPTO_DATA:
-        regime_benchmark_str = 'BTC-USD'
-        tickers = [regime_benchmark_str, 'ETH-USD', 'SOL-USD']
+        regime_benchmark = 'BTC-USD'
+        tickers = [regime_benchmark, 'ETH-USD', 'SOL-USD']
 
     else:
         raise NotImplementedError
@@ -160,7 +160,7 @@ def run_unit_test(unit_test: UnitTests):
         prices = time_period.locate(prices)
 
     generate_performances(prices=prices,
-                          regime_benchmark_str=regime_benchmark_str,
+                          regime_benchmark=regime_benchmark,
                           **kwargs)
 
     plt.show()

{qis-3.0.5 → qis-3.0.7}/qis/examples/vix_conditional_returns.py

@@ -35,7 +35,7 @@ monthly_df = pd.concat([monthly_return, predictor_1, monthly_benchmark_vol_1, vi
 with sns.axes_style("darkgrid"):
     fig1, axs = plt.subplots(2, 3, figsize=(18, 9))
     qis.plot_prices_with_dd(prices=prices[[benchmark_name, strategy_name]],
-                            regime_benchmark_str=benchmark_name,
+                            regime_benchmark=benchmark_name,
                             perf_stats_labels=[PerfStat.PA_RETURN, PerfStat.VOL, PerfStat.SHARPE_RF0, PerfStat.MAX_DD],
                             title=f"Performances of ShortVix (SPVXSPI Index) and SPX (SPXT Index)",
                             x_date_freq='YE',

{qis-3.0.5 → qis-3.0.7}/qis/file_utils.py

@@ -231,17 +231,21 @@ def save_df_to_excel(data: Union[pd.DataFrame, List[pd.DataFrame], Dict[str, pd.
         if sheet_names is None:
             sheet_names = [f"Sheet {n+1}" for n, _ in enumerate(data)]
         for df, name in zip(data, sheet_names):
-            df = delocalize_df(df)
-            if transpose:
-                df = df.T
-            df.to_excel(excel_writer=excel_writer, sheet_name=name)
+            if df is not None:
+                df = delocalize_df(df)
+                if transpose:
+                    df = df.T
+                df.to_excel(excel_writer=excel_writer, sheet_name=name)
     elif isinstance(data, dict):  # publish with sheet names
         for key, df in data.items():
-            df = delocalize_df(df)
-            if transpose:
-                df = df.T
-            df.to_excel(excel_writer=excel_writer, sheet_name=key)
+            if df is not None:
+                df = delocalize_df(df)
+                if transpose:
+                    df = df.T
+                df.to_excel(excel_writer=excel_writer, sheet_name=key)
     else:
+        if data is None:
+            raise ValueError(f"None data")
         if transpose:
             data = data.T
         data = delocalize_df(data)

{qis-3.0.5 → qis-3.0.7}/qis/models/linear/plot_correlations.py

@@ -97,7 +97,7 @@ def plot_returns_corr_matrix_time_series(prices: pd.DataFrame,
                                          var_format: str = '{:.0%}',
                                          legend_stats: pts.LegendStats = pts.LegendStats.AVG_LAST,
                                          trend_line: put.TrendLine = put.TrendLine.AVERAGE,
-                                         regime_benchmark_str: str = None,
+                                         regime_benchmark: str = None,
                                          regime_params: BenchmarkReturnsQuantileRegimeSpecs = None,
                                          perf_params: PerfParams = None,
                                          ax: plt.Subplot = None,
@@ -124,16 +124,16 @@ def plot_returns_corr_matrix_time_series(prices: pd.DataFrame,
                          var_format=var_format,
                          ax=ax,
                          **kwargs)
-    if regime_benchmark_str is not None:
-        if regime_benchmark_str in prices.columns:
-            pivot_prices = prices[regime_benchmark_str].reindex(index=corr_pandas.index, method='ffill')
+    if regime_benchmark is not None:
+        if regime_benchmark in prices.columns:
+            pivot_prices = prices[regime_benchmark].reindex(index=corr_pandas.index, method='ffill')
         else:
-            raise KeyError(f"{regime_benchmark_str} not in {prices.columns}")
+            raise KeyError(f"{regime_benchmark} not in {prices.columns}")
 
-        if regime_benchmark_str is not None and regime_params is not None:
+        if regime_benchmark is not None and regime_params is not None:
             add_bnb_regime_shadows(ax=ax,
                                    pivot_prices=pivot_prices,
-                                   benchmark=regime_benchmark_str,
+                                   benchmark=regime_benchmark,
                                    regime_params=regime_params,
                                    perf_params=perf_params)
 
@@ -154,7 +154,7 @@ def run_unit_test(unit_test: UnitTests):
 
     elif unit_test == UnitTests.CORR_MATRIX:
         fig, ax = plt.subplots(1, 1, figsize=(10, 10), constrained_layout=True)
-        plot_returns_corr_matrix_time_series(prices=prices, regime_benchmark_str='SPY', ax=ax)
+        plot_returns_corr_matrix_time_series(prices=prices, regime_benchmark='SPY', ax=ax)
 
     elif unit_test == UnitTests.EWMA_CORR:
         plot_returns_ewm_corr_table(prices=prices.iloc[:, :5])

{qis-3.0.5 → qis-3.0.7}/qis/plots/derived/prices.py

@@ -64,7 +64,7 @@ def get_performance_labels_for_stats(prices: Union[pd.DataFrame, pd.Series],
 def plot_prices(prices: Union[pd.DataFrame, pd.Series],
                 perf_stats_labels: List[PerfStat] = (PerfStat.PA_RETURN, PerfStat.VOL, PerfStat.SHARPE_RF0, ),
                 perf_params: PerfParams = None,
-                regime_benchmark_str: str = None,  # to add regimes
+                regime_benchmark: str = None,  # to add regimes
                 pivot_prices: pd.Series = None,
                 regime_params: BenchmarkReturnsQuantileRegimeSpecs = BenchmarkReturnsQuantileRegimeSpecs(),
                 var_format: str = '{:,.1f}',
@@ -110,11 +110,11 @@ def plot_prices(prices: Union[pd.DataFrame, pd.Series],
                                ax=ax,
                                **kwargs)
 
-    if regime_benchmark_str is not None and regime_params is not None:
+    if regime_benchmark is not None and regime_params is not None:
         add_bnb_regime_shadows(ax=ax,
                                data_df=prices,
                                pivot_prices=pivot_prices,
-                               benchmark=regime_benchmark_str,
+                               benchmark=regime_benchmark,
                                regime_params=regime_params)
     return fig
 
@@ -123,7 +123,7 @@ def plot_prices_with_dd(prices: Union[pd.DataFrame, pd.Series],
                         perf_stats_labels: List[PerfStat] = (PerfStat.PA_RETURN, PerfStat.VOL,
                                                              PerfStat.SHARPE_RF0),
                         perf_params: PerfParams = None,
-                        regime_benchmark_str: str = None,  # to add regimes
+                        regime_benchmark: str = None,  # to add regimes
                         pivot_prices: pd.Series = None,
                         regime_params: BenchmarkReturnsQuantileRegimeSpecs = BenchmarkReturnsQuantileRegimeSpecs(),
                         var_format: str = '{:,.1f}',
@@ -174,12 +174,12 @@ def plot_prices_with_dd(prices: Union[pd.DataFrame, pd.Series],
     if remove_xticklabels_ax1:
         axs[0].set_xticklabels('')
 
-    if (regime_benchmark_str is not None or pivot_prices is not None) and regime_params is not None:
+    if (regime_benchmark is not None or pivot_prices is not None) and regime_params is not None:
         for ax in axs:
             add_bnb_regime_shadows(ax=ax,
                                    data_df=prices,
                                    pivot_prices=pivot_prices,
-                                   benchmark=regime_benchmark_str,
+                                   benchmark=regime_benchmark,
                                    regime_params=regime_params,
                                    perf_params=perf_params)
     return fig
@@ -190,7 +190,7 @@ def plot_prices_with_fundamentals(prices: Union[pd.DataFrame, pd.Series],
                                   mcap: Union[pd.DataFrame, pd.Series],
                                   perf_stats_labels: List[PerfStat] = (PerfStat.PA_RETURN, PerfStat.VOL, PerfStat.SHARPE_RF0, ),
                                   perf_params: PerfParams = None,
-                                  regime_benchmark_str: str = None,  # to add regimes
+                                  regime_benchmark: str = None,  # to add regimes
                                   pivot_prices: pd.Series = None,
                                   regime_params: BenchmarkReturnsQuantileRegimeSpecs = BenchmarkReturnsQuantileRegimeSpecs(),
                                   trend_line: put.TrendLine = put.TrendLine.AVERAGE,
@@ -242,12 +242,12 @@ def plot_prices_with_fundamentals(prices: Union[pd.DataFrame, pd.Series],
     axs[0].set_xticklabels('')
     axs[1].set_xticklabels('')
 
-    if regime_benchmark_str is not None and regime_params is not None:
+    if regime_benchmark is not None and regime_params is not None:
         for ax in axs:
             add_bnb_regime_shadows(ax=ax,
                                    data_df=prices,
                                    pivot_prices=pivot_prices,
-                                   benchmark=regime_benchmark_str,
+                                   benchmark=regime_benchmark,
                                    regime_params=regime_params,
                                    perf_params=perf_params)
     return fig
@@ -313,7 +313,7 @@ def plot_rolling_perf_stat(prices: Union[pd.Series, pd.DataFrame],
                            roll_freq: str = None,
                            legend_stats: pts.LegendStats = pts.LegendStats.AVG_LAST,
                            title: Optional[str] = None,
-                           regime_benchmark_str: str = None,
+                           regime_benchmark: str = None,
                            pivot_prices: pd.Series = None,
                            regime_params: BenchmarkReturnsQuantileRegimeSpecs = BenchmarkReturnsQuantileRegimeSpecs(),
                            perf_params: PerfParams = None,
@@ -337,11 +337,11 @@ def plot_rolling_perf_stat(prices: Union[pd.Series, pd.DataFrame],
                                ax=ax,
                                **sop.update_kwargs(kwargs, dict(var_format=rolling_perf_stat.value[1])))
 
-    if regime_benchmark_str is not None and regime_params is not None:
+    if regime_benchmark is not None and regime_params is not None:
         add_bnb_regime_shadows(ax=ax,
                                data_df=prices.reindex(index=df.index, method='ffill'),
                                pivot_prices=pivot_prices,
-                               benchmark=regime_benchmark_str,
+                               benchmark=regime_benchmark,
                                regime_params=regime_params,
                                perf_params=perf_params)
 
@@ -373,7 +373,7 @@ def run_unit_test(unit_test: UnitTests):
     elif unit_test == UnitTests.PRICE_WITH_DD:
         perf_params = PerfParams(freq='ME')
         plot_prices_with_dd(prices=prices,
-                            regime_benchmark_str=prices.columns[0],
+                            regime_benchmark=prices.columns[0],
                             perf_params=perf_params)
 
     plt.show()

{qis-3.0.5 → qis-3.0.7}/qis/plots/derived/regime_scatter.py

@@ -16,7 +16,7 @@ from qis.perfstats.regime_classifier import BenchmarkReturnsQuantileRegimeSpecs,
 
 
 def plot_scatter_regression(prices: pd.DataFrame,
-                            regime_benchmark_str: str,
+                            regime_benchmark: str,
                             regime_params: BenchmarkReturnsQuantileRegimeSpecs = BenchmarkReturnsQuantileRegimeSpecs(),
                             drop_benchmark: bool = True,
                             x_var_format: str = '{:.0%}',
@@ -41,7 +41,7 @@ def plot_scatter_regression(prices: pd.DataFrame,
 
     regmodel_out_dict = {}
     estimated_params = cre.estimate_cond_regression(prices=prices,
-                                                    benchmark=regime_benchmark_str,
+                                                    benchmark=regime_benchmark,
                                                     drop_benchmark=drop_benchmark,
                                                     regime_params=regime_params,
                                                     is_print_summary=is_print_summary,
@@ -52,8 +52,8 @@ def plot_scatter_regression(prices: pd.DataFrame,
     lines = []
     for (asset, pandas_out), marker, color_ in zip(regmodel_out_dict.items(), markers, colors):
 
-        pandas_out = pandas_out.sort_values(regime_benchmark_str)  # sort for line plot
-        sns.scatterplot(x=regime_benchmark_str,
+        pandas_out = pandas_out.sort_values(regime_benchmark)  # sort for line plot
+        sns.scatterplot(x=regime_benchmark,
                         y=asset,
                         hue=pandas_out[BenchmarkReturnsQuantilesRegime.REGIME_COLUMN],
                         data=pandas_out,
@@ -77,7 +77,7 @@ def plot_scatter_regression(prices: pd.DataFrame,
             line_marker = marker
             lines.append((asset, {'color': color_, 'linestyle': '-', 'marker': line_marker}))
 
-        sns.lineplot(x=regime_benchmark_str,
+        sns.lineplot(x=regime_benchmark,
                      y=cre.PREDICTION,
                      hue=pandas_out[BenchmarkReturnsQuantilesRegime.REGIME_COLUMN],
                      data=pandas_out,
@@ -89,7 +89,7 @@ def plot_scatter_regression(prices: pd.DataFrame,
     if add_last_date:
         label_x_y = {}
         for asset, df in regmodel_out_dict.items():
-            x = df[regime_benchmark_str].iloc[-1]
+            x = df[regime_benchmark].iloc[-1]
             y = df[asset].iloc[-1]
             label = f"Last {df.index[-1].strftime('%d-%b-%Y')}: x={x_var_format.format(x)}, y={x_var_format.format(y)}"
             label_x_y[label] = (x, y)
@@ -104,7 +104,7 @@ def plot_scatter_regression(prices: pd.DataFrame,
     ax.yaxis.set_major_formatter(FuncFormatter(lambda y, _: y_var_format.format(y)))
 
     if xlabel is None:
-        xlabel = f"x={regime_benchmark_str}"
+        xlabel = f"x={regime_benchmark}"
     if ylabel is None:
         if len(prices.columns) == 2:
             ylabel = f"y = {asset}"
@@ -133,14 +133,14 @@ def run_unit_test(unit_test: UnitTests):
 
     if unit_test == UnitTests.SCATTER_ALL:
         plot_scatter_regression(prices=prices,
-                                regime_benchmark_str='SPY',
+                                regime_benchmark='SPY',
                                 regime_params=regime_params,
                                 add_last_date=True,
                                 is_asset_detailed=False)
 
     elif unit_test == UnitTests.SCATTER_1:
         plot_scatter_regression(prices=prices[['SPY', 'TLT']],
-                                regime_benchmark_str='SPY',
+                                regime_benchmark='SPY',
                                 regime_params=regime_params,
                                 add_last_date=True,
                                 is_asset_detailed=True)

{qis-3.0.5 → qis-3.0.7}/qis/portfolio/__init__.py

@@ -27,6 +27,7 @@ from qis.portfolio.reports.config import (FactsheetConfig,
                                           ReportingFrequency)
 
 from qis.portfolio.reports.brinson_attribution import (compute_brinson_attribution_table,
+                                                       plot_brinson_totals_table,
                                                        plot_brinson_attribution_table)
 
 from qis.portfolio.reports.multi_assets_factsheet import (MultiAssetsReport, generate_multi_asset_factsheet)