added side nav bar

appComponents.py

@@ -15,202 +15,6 @@ import plotly.graph_objs as go
 pn.extension('mathjax')
 pn.extension('plotly')
 
-# warnings.filterwarnings("ignore", category=pd.core.common.SettingWithCopyWarning)
-# overal performance default to 30 days
-
-
-def create_portfolio_overview(df_list):
-    calculated_b_stock, calculated_p_stock, p_eval_df, sector_eval_df = df_list
-
-    range_slider = pn.widgets.DateRangeSlider(name='date range',
-                                              start=sector_eval_df.date.min(),
-                                              end=sector_eval_df.date.max(),
-                                              value=(sector_eval_df.date.max() - timedelta(days=30),
-                                                     sector_eval_df.date.max()),
-                                              align='center',
-                                              sizing_mode='stretch_width',
-                                              )
-    size = dict(width=780)
-    option = dict(legend_position="left")
-    active_tools = dict(tools=['hover'], active_tools=[], axiswise=True)
-
-    # def create_overview_panel()
-    ip_eval_df = p_eval_df.interactive()
-    isector_eval_df = sector_eval_df.interactive()
-
-    ranged_ip_eval_df = ip_eval_df[ip_eval_df.date.between(
-        range_slider.param.value_start, range_slider.param.value_end)]
-    ranged_isector_eval_df = isector_eval_df[isector_eval_df.date.between(
-        range_slider.param.value_start, range_slider.param.value_end)]
-    # return
-    return_plot = ranged_ip_eval_df.hvplot.line(x='date', y=['portfolio_return_p', 'portfolio_return_b'])\
-        .opts(title='投资组合总回报 v.s benchmark总回报', **size, **option)
-    # active return
-    active_return_plot = ranged_ip_eval_df.hvplot.line(x='date', y=['active_return'])\
-        .opts(title='每日主动回报',  **size, axiswise=True)
-
-    # total risk and tracking error
-    risk_tracking_plot = ranged_ip_eval_df.hvplot.line(x='date', y=['risk', 'tracking_error'])\
-        .opts(title='风险和追踪误差', **size, **option)
-
-    # sector return
-    sector_return_plot = ranged_isector_eval_df.hvplot.line(x='date', y=['portfolio_return_p'], by='aggregate_sector')\
-        .opts(title='投资组合各行业总回报',  **size, **option)
-
-    # bsector_return_plot = ranged_isector_eval_df.hvplot.line(x='date', y=['portfolio_return_b'], by='aggregate_sector')\
-    #     .opts(title='benchmark sector return',  **size, **option)
-
-    # sector active return
-    s_active_return_plot = ranged_isector_eval_df.hvplot.line(x='date', y=['active_return'], by='aggregate_sector')\
-        .opts(title='投资组合各行业每日主动回报',  **size, **option)
-
-    # sector risk and tracking error
-    s_risk_plot = ranged_isector_eval_df.hvplot.line(x='date', y=['tracking_error'], by='aggregate_sector')\
-        .opts(title='投资组合各行业追踪误差',  **size, **option)
-    s_tracking_plot = ranged_isector_eval_df.hvplot.line(x='date', y=['risk'], by='aggregate_sector')\
-        .opts(title='投资组合各行业风险', **size, **option)
-
-    # attribute
-    def create_attribute_plot(start, end, calculated_b_stock, calculated_p_stock):
-        result = processing.calculate_attributes_between_dates(
-            start, end, calculated_b_stock, calculated_p_stock)
-        portfolio_attribute = result.aggregate({
-            'interaction': 'sum',
-            'allocation': 'sum',
-            'selection': 'sum',
-        })
-        layout = pn.Column(
-            pn.pane.DataFrame(portfolio_attribute.transpose()),
-            result.hvplot.bar(x='display_name_p',
-                              y=['interaction', 'allocation', 'selection'],
-                              shared_axes=False,
-                              stacked=True,
-                              rot=90).opts(**size, **option, title='投资组合总主动回报归因')
-        )
-        return layout
-
-    attribute_plot = pn.bind(create_attribute_plot,
-                             start=range_slider.param.value_start,
-                             end=range_slider.param.value_end,
-                             calculated_b_stock=calculated_b_stock,
-                             calculated_p_stock=calculated_p_stock)
-
-    # stock performance
-    # selected_p_stock = calculated_p_stock[calculated_p_stock.date ==
-    #                                       calculated_p_stock.date.max()]
-    # stock_radar_plot = go.Figure()
-    # category = ['return', 'risk', 'portfolio_return', 'prev_w_in_p']
-    # for display_name, group in selected_p_stock.groupby('display_name'):
-    #     stock_radar_plot.add_trace(go.Scatterpolar(
-    #         r=group[category].values[0],
-    #         theta=category,
-    #         fill='toself',
-    #         name=display_name
-    #     ))
-    total_view_plots = pn.Column(return_plot.opts(**active_tools).output(),
-                                 risk_tracking_plot.opts(
-                                     **active_tools).output(),
-                                 active_return_plot.opts(
-                                     **active_tools).output(),
-                                 attribute_plot,
-                                 height=1000,
-                                 scroll=True)
-    sector_view_plots = pn.Column(sector_return_plot.opts(**active_tools).output(),
-                                  s_risk_plot.opts(**active_tools).output(),
-                                  s_tracking_plot.opts(
-                                      **active_tools).output(),
-                                  s_active_return_plot.opts(
-                                      **active_tools).output(),
-                                  height=1000,
-                                  scroll=True)
-
-    return pn.Column(
-        # pn.Row(align='center'),
-        range_slider,
-        pn.Row(total_view_plots, sector_view_plots, align='center'))
-
-
-def attribution_view(daily_bnb_result, daily_sector_bnb_result, p_eval_df):
-    p_eval_df.date = pd.to_datetime(p_eval_df.date)
-    daily_bnb_result.date = pd.to_datetime(daily_bnb_result.date)
-    daily_sector_bnb_result.date = pd.to_datetime(daily_sector_bnb_result.date)
-
-    # interactive widget
-    dt_range = pn.widgets.DateRangeSlider(start=p_eval_df.date.min(
-    ), end=p_eval_df.date.max(), value=(p_eval_df.date.min(), p_eval_df.date.max()))
-    # total attribution and return
-    p_eval_df_i = p_eval_df.interactive()
-    daily_bnb_result_i = daily_bnb_result.interactive()
-    daily_return_plot = p_eval_df_i[(p_eval_df_i.date >= dt_range.param.value_start) & (
-        p_eval_df_i.date <= dt_range.param.value_end)].hvplot(x='date', y=['portfolio_return_p', 'portfolio_return_b'], title='投资组合总回报 v.s benchmark总回报').output()
-    daily_bnb_plot = daily_bnb_result_i[daily_bnb_result_i.date.between(dt_range.param.value_start, dt_range.param.value_end)]\
-        .hvplot.bar(x='date', y=['allocation', 'selection', 'interaction', "active_return"], stacked=True, title='每日主动收益归因', yformatter='%.2f', xlabel='日期', shared_axes=False).output()
-
-    # return
-    daily_sector_bnb_df_i = daily_sector_bnb_result.interactive()
-    selected_range_df = daily_sector_bnb_df_i[daily_sector_bnb_df_i.date.between(
-        dt_range.param.value_start, dt_range.param.value_end)]
-    sector_active_return_plot = selected_range_df.hvplot.line(
-        x='date', y='active_return', by='aggregate_sector', width=1000, height=400, title='投资组合行业每日主动回报').output()
-
-    # attribution
-    def plot_attribute_by_sector(sector):
-        selected_sector_df = selected_range_df[selected_range_df.aggregate_sector == sector]
-        return selected_sector_df.hvplot.bar(x='date', y=['active_return', 'allocation', 'selection', 'interaction'], title='投资组合行业每日主动收入归因', stacked=True, shared_axes=False).output()
-    sector_attr_plot_tabs = pn.Tabs(*[(sector, plot_attribute_by_sector(sector))
-                                    for sector in daily_sector_bnb_result.aggregate_sector.unique()], dymacic=True)
-
-    # layout
-    sector_view = pn.Column(sector_attr_plot_tabs, sector_active_return_plot)
-    total_view = pn.Column(daily_return_plot, daily_bnb_plot)
-    return pn.Column(
-        pn.Row(dt_range),
-        pn.Row(total_view, sector_view)
-    )
-
-# plot explore
-
-
-def create_hvplot_explore(calculated_b_stock, calculated_p_stock, p_eval_df, sector_eval_df, attribution_result_df, s_attribution_result_df):
-
-    options = ['calculated_b_stock', 'calculated_p_stock', 'p_eval_df',
-               'sector_eval_df', 'attribution_result_df', 's_attribution_result_df']
-    name_to_df = {
-        'calculated_b_stock': calculated_b_stock,
-        'calculated_p_stock': calculated_p_stock,
-        'p_eval_df': p_eval_df,
-        'sector_eval_df': sector_eval_df,
-        'attribution_result_df': attribution_result_df,
-        's_attribution_result_df': s_attribution_result_df
-
-    }
-
-    selector = pn.widgets.Select(
-        name='Select', options=options, value=options[0])
-
-    def create_exploer(name):
-        df = name_to_df[name]
-        explorer = hvplot.explorer(df)
-
-        def plot_code(**kwargs):
-            code = f'```python\n{explorer.plot_code()}\n```'
-            return pn.pane.Markdown(code, sizing_mode='stretch_width')
-        pn.Column(
-            explorer,
-            '**Code**:',
-            pn.bind(plot_code, **explorer.param.objects())
-        )
-        return explorer
-
-    def create_perspective(name):
-        df = name_to_df[name]
-        return pn.pane.Perspective(df, columns=list(df.columns), width=1500, height=800)
-    perspective = pn.bind(create_perspective, name=selector)
-    exploer = pn.bind(create_exploer, name=selector)
-    exploer_component = pn.Column(selector, exploer, perspective)
-    return exploer_component
-
-
 class TotalReturnCard(Viewer):
 
     start_date = param.Parameter()
@@ -910,21 +714,31 @@ class TopHeader(Viewer):
         '''
         return
 
-    def calculation(self):
-        '''calculate PnL, total return and max drawdown'''
-        pnl = self.eval_df[self.eval_df.date ==
-                           self.eval_df.date.max()].cum_pnl.values[0]
-        total_return = self.eval_df[self.eval_df.date ==
-                                    self.eval_df.date.max()].portfolio_return_p.values[0]
-        # max draw down
-        self.eval_df['rolling_max_return'] = self.eval_df.portfolio_return_p.rolling(
-            window=len(self.eval_df), min_periods=1).max()
-        self.eval_df.draw_down = abs(
-            (1 + self.eval_df.portfolio_return_p) /
-            (1 + self.eval_df.rolling_max_return) - 1
-        )
-        max_drawdown = self.eval_df.draw_down.max()
-        return pnl, total_return, max_drawdown
+    def _process(self):
+        '''calculate accumulative pnl, total return and Max Drawdown on return'''
+        
+        # return
+        result_df = processing.calculate_weighted_return(self.eval_df)
+        
+        # merge by date
+        agg_df = result_df.groupby('time').aggregate({
+                    'weighted_return': 'sum',
+                    'cash': 'sum',
+                    'pnl': 'sum',
+                })
+        agg_df.reset_index(inplace=True)
+
+        # accumulative pnl
+        agg_df['cum_pnl'] = agg_df['pnl'].cumsum()
+        
+        # calcualte drawdown
+        result = processing.calculate_draw_down_on(agg_df)
+        max_draw_down = result.drawn_down.min()
+
+        # last row
+        last_row = agg_df.loc[agg_df.time.idxmax()]
+
+        return last_row.cum_pnl, last_row.weighted_return, max_draw_down
 
     def create_report(self, pnl, total_return, max_drawdown):
         return pn.FlexBox(
@@ -932,8 +746,8 @@ class TopHeader(Viewer):
 
     def __init__(self, eval_df, **params):
         self.eval_df = eval_df
-        pnl, total_return, max_drawdown = self.calculation()
-        self.report = self.create_report(pnl, total_return, max_drawdown)
+        cum_pnl, total_return, max_drawdown = self._process()
+        self.report = self.create_report(cum_pnl, total_return, max_drawdown)
         super().__init__(**params)
 
     def __panel__(self):

index_page.py

@@ -4,6 +4,7 @@ from datetime import datetime, timedelta
 import plotly.express as px
 import holoviews as hv
 import numpy as np
+from sidebar import SideNavBar
 import random
 import scipy.stats as stats
 import hvplot.pandas  # noqa
@@ -49,28 +50,23 @@ total_return_card = appComponents.TotalReturnCard(name='Range',
 drawdown_card = appComponents.DrawDownCard(
    calculated_p_stock=analytic_p)
 
-# top_header = appComponents.TopHeader(
-#     eval_df=p_eval_df
-# )
+top_header = appComponents.TopHeader(
+    eval_df = analytic_p,
+)
 
 template = pn.template.FastListTemplate(
     title="Portfolio一览",
     # sidebar=[freq, phase],
 )
-template.main.extend([drawdown_card, stock_overview, composation_card, monthly_return_card, total_return_card])
-# template.main.extend(
-#     [pn.Row(top_header),
-#      pn.Row(
-#         pn.Column(monthly_return_card, stock_overview,
-#                   width=500, margin=(10, 10, 10, 10)),
-#         pn.Column(total_return_card, drawdown_card, margin=(10, 10, 10, 10)),
-#         pn.Column(composation_card, margin=(10, 10, 10, 10)),
-#     )]
-# )
+template.sidebar.append(SideNavBar())
+# template.main.extend([drawdown_card, stock_overview, composation_card, monthly_return_card, total_return_card])
+template.main.extend(
+    [pn.Row(top_header),
+     pn.Row(
+        pn.Column(monthly_return_card, stock_overview,
+                  width=500, margin=(10, 10, 10, 10)),
+        pn.Column(total_return_card, drawdown_card, margin=(10, 10, 10, 10)),
+        pn.Column(composation_card, margin=(10, 10, 10, 10)),
+    )]
+)
 template.servable()
-# pn.Row(
-
-#     pn.Column(monthly_return_card, stock_overview, width=500),
-#     pn.Column(total_return_card),
-#     pn.Column(composation_card)
-# ).servable()

instance/local.db

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5e731caeff97539825bee38f510c68ccf49001da6f3fed73058ea4ba7891efdc
-size 19148800
+oid sha256:cbb513c601ed039cdf11c093c2192afc7383eaa8f9db8f7dead5fba68a94ff0d
+size 164798464

instance/log.json

@@ -1,3 +1,3 @@
 {
-    "daily_update": "2023-08-31 19:34:56"
+    "daily_update": "2023-08-31 23:45:18"
 }

pipeline.py

@@ -139,8 +139,6 @@ def need_to_update_stocks_price(delta_time):
                 return False
 
 
-
-
 def add_details_to_stock_df(stock_df):
     with create_engine(db_url).connect() as conn:
         detail_df = pd.read_sql(ts.STOCKS_DETAILS_TABLE, con=conn)
@@ -407,26 +405,36 @@ def batch_processing():
     # pnl
     processing.calculate_pnl(analytic_p)
     # log return
-    # need to crop on left side of benchmark 
-    analytic_b = analytic_b[analytic_b['time'] >= analytic_p.time.min()].copy() 
+    # need to crop on left side of benchmark
+    analytic_b = analytic_b[analytic_b['time'] >= analytic_p.time.min()].copy()
     processing.calculate_log_return(analytic_p)
     processing.calculate_log_return(analytic_b)
     db.save_portfolio_analytic_df(analytic_p)
     db.save_benchmark_analytic_df(analytic_b)
 
+
 async def daily_update():
+    '''
+    left and right fill stock price and benchmark weight based on portfolio
+
+    the sequence of the update matter,
+    specifically the benchmark profile need to be updated first before stock,
+    cause update method of stock price depend on the benchmark profile
+
+    '''
     last_update = log.get_time('daily_update')
+    # check if need to update
     if last_update is None or utils.time_in_beijing() - last_update >= dt.timedelta(days=1):
         print("running daily update")
-        # check if need to update
+
+        # update benchmark index, this need to be done before update stock price
+        left_fill_benchmark_profile()
+        right_fill_bechmark_profile()
+        print("updated benchmark profile")
         # update stock price
         left_fill_stocks_price()
         right_fill_stock_price()
         print("updated stocks price")
-        # update benchmark index
-        left_fill_benchmark_profile()
-        right_fill_bechmark_profile()
-        print("updated benchmark profile")
         # update all stock detail
         update_stocks_details_to_db()
         print("updated stocks details")

portfolioEditingPage.py

@@ -12,6 +12,7 @@ from pipeline import update_portfolio_profile_to_db
 import table_schema
 import pipeline
 import db_operation as db
+from sidebar import SideNavBar
 db_url = 'sqlite:///instance/local.db'
 pn.extension()
 pn.extension('tabulator')
@@ -349,5 +350,6 @@ def app():
 
 # app
 template = pn.template.FastListTemplate(title='portfolio编辑')
+template.sidebar.append(SideNavBar())
 template.main.append(app())
 template.servable()

processing.py

@@ -690,7 +690,7 @@ def post_process_merged_analytic_df(merged_df):
     patch aggregate_sector, display_name, in_portfolio, in_benchmark,
 
     '''
-    # merge both   
+    # merge both
     merged_df['in_portfolio'].fillna(False, inplace=True)
     merged_df['in_benchmark'].fillna(False, inplace=True)
     # complement fill aggregate_sector and display_name
@@ -703,7 +703,7 @@ def post_process_merged_analytic_df(merged_df):
     merged_df.drop(columns=['aggregate_sector_p',
                    'display_name_p'], inplace=True)
 
-    
+
 def calculate_weighted_pct(df):
     '''
     patch df with weighted pct, if pct is not calculated patch that as well
@@ -712,6 +712,7 @@ def calculate_weighted_pct(df):
         calculate_pct(df)
     df['weighted_pct'] = df['pct'] * df['weight']
 
+
 def aggregate_analytic_df_by_period(df, freq):
     '''
     return an aggregated analytic_df with weekly, monthly, yearly or daily frequency
@@ -753,7 +754,7 @@ def aggregate_analytic_df_by_period(df, freq):
                  'log_return': 'sum',
                  'weight': 'last'
                  }
-    
+
     # handle aggregate on benchamrk
     if 'cash' in df.columns and 'shares' in df.columns:
         agg_rules['cash'] = 'last'
@@ -779,6 +780,7 @@ def aggregate_bhb_df(df, by="total"):
                                'notional_active_return']].sum()
     return agg_df
 
+
 def calculate_draw_down_on(df, key='weighted_return'):
     '''
     calculate draw down on anlaytic df based on either return or accumulative pnl
@@ -798,12 +800,12 @@ def calculate_draw_down_on(df, key='weighted_return'):
             window=len(df), min_periods=1).max()
         if key == 'pnl':
             df['drawn_down'] = df[key] / df[f'rolling_max_{key}']
-        
+
         else:
-            df['drawn_down'] =  (1 + df[key]) / (1 + df[f'rolling_max_{key}'])
-            
+            df['drawn_down'] = (1 + df[key]) / (1 + df[f'rolling_max_{key}'])
+
         return df
-    
+
 # def calculate_accumulative_pnl(df):
 #     '''
 #     calculate accumulative pnl on analytic df
@@ -812,4 +814,4 @@ def calculate_draw_down_on(df, key='weighted_return'):
 #     df['accumulative_pnl'] = df.groupby('ticker')['pnl'].rolling(
 
 #     )
-#     return df
+#     return df

sidebar.py

@@ -0,0 +1,30 @@
+from panel.viewable import Viewer
+import panel as pn
+
+
+class SideNavBar(Viewer):
+
+    def __init__(self, **params):
+        self.pages = {
+            '编辑Portfolio': "/portfolioEditingPage",
+            '主页': "/index_page",
+        }
+        self.styles = {
+            'text-decoration': 'none',
+            'color': '#1E90FF',
+            'font-size': '18px',
+            'font-weight': 'bold'
+        }
+
+        super().__init__(**params)
+
+    def _create_link(self, name, url):
+        return pn.pane.HTML(f"""<a href="{url}">{name}</a>""", styles=self.styles)
+
+    def __panel__(self):
+
+        self._layout = pn.Column()
+        self._layout.extend(
+            [self._create_link(name, url) for name, url in self.pages.items()]
+        )
+        return self._layout