second commit

app copy.py

@@ -1,135 +0,0 @@
-import gradio as gr
-import pandas as pd
-
-tools = pd.read_csv("./data/tools.csv")
-# all_trades = pd.read_csv('./data/all_trades_profitability.csv')
-
-demo = gr.Blocks()
-
-INC_TOOLS = [
-    'prediction-online', 
-    'prediction-offline', 
-    'claude-prediction-online', 
-    'claude-prediction-offline', 
-    'prediction-offline-sme',
-    'prediction-online-sme',
-    'prediction-request-rag',
-    'prediction-request-reasoning',
-    'prediction-url-cot-claude', 
-    'prediction-request-rag-claude',
-    'prediction-request-reasoning-claude'
-]
-
-def set_error(row):
-    if row.error not in [True, False]:
-        if not row.prompt_response:
-            return True
-        return False
-    return row.error
-
-def get_error_data():
-    tools_inc = tools[tools['tool'].isin(INC_TOOLS)]
-    tools_inc['error'] = tools_inc.apply(set_error, axis=1)
-    error = tools_inc.groupby(['tool', 'request_month_year_week', 'error']).size().unstack().fillna(0).reset_index()
-    error['error_perc'] = (error[True] / (error[False] + error[True]))*100
-    error['total_requests'] = error[False] + error[True]
-
-    return error
-
-def get_error_data_all(error):
-    error_total = error.groupby('request_month_year_week').agg({'total_requests': 'sum', False: 'sum', True:'sum'}).reset_index()
-    error_total['error_perc'] = (error_total[True] / error_total['total_requests'])*100
-    # convert column name to string
-    error_total.columns = error_total.columns.astype(str)
-    # format all values to 4 decimal places for error_perc
-    error_total['error_perc'] = error_total['error_perc'].apply(lambda x: round(x, 4))
-    return error_total
-
-error = get_error_data()
-error_all = get_error_data_all(error)
-print(error_all.head())
-
-with demo:
-    gr.HTML("<h1>Olas Predict Actual Performance</h1>")
-    gr.Markdown("This app shows the actual performance of Olas Predict tools on the live market.")
-
-    with gr.Tabs():
-        with gr.TabItem("🔥 Error Dashboard"):
-            with gr.Row():
-                gr.Markdown("This plot shows the percentage of requests that resulted in an error.")
-            with gr.Row():
-                # plot 
-                with gr.Column():
-                    gr.LinePlot(
-                        value=error_all,
-                        x="request_month_year_week",
-                        y="error_perc",
-                        title="Error Percentage",
-                        x_title="Week",
-                        y_title="Error Percentage",
-                        height=400,
-                        show_label=True
-                    )
-            gr.Markdown("This plot shows the percentage of requests that resulted in an error.")
-            
-            # Dropdown for selecting the tool
-            sel_tool = gr.Dropdown(
-                value="prediction-online", 
-                choices=INC_TOOLS, 
-                label="Select a tool"
-            )
-            plot_tool_error = gr.LinePlot(
-                title="Error Percentage", 
-                x_title="Week", 
-                y_title="Error Percentage",
-                render=False
-            )
-            
-            # Dropdown for selecting the week
-            sel_week = gr.Dropdown(
-                value=error['request_month_year_week'].iloc[-1], 
-                choices=error['request_month_year_week'].unique().tolist(), 
-                label="Select a week"
-            )
-            plot_week_error = gr.BarPlot(
-                title="Error Percentage", 
-                x_title="Tool", 
-                y_title="Error Percentage",
-                render=False
-            )
-
-            def update_tool_plot(selected_tool):
-                filtered_data = error[error['tool'] == selected_tool]
-                # convert column name to string
-                filtered_data.columns = filtered_data.columns.astype(str)
-                # conver error_perc to 4 decimal place
-                filtered_data['error_perc'] = filtered_data['error_perc'].apply(lambda x: round(x, 4))
-                print(filtered_data.head())
-                return {
-                    "x": filtered_data['request_month_year_week'].tolist(),
-                    "y": filtered_data['error_perc'].tolist(),
-                }
-            
-            def update_week_plot(selected_week):
-                filtered_data = error[error['request_month_year_week'] == selected_week]
-                filtered_data.columns = filtered_data.columns.astype(str)
-                filtered_data['error_perc'] = filtered_data['error_perc'].apply(lambda x: round(x, 4))
-                print(filtered_data.head())
-                return {
-                    "x": filtered_data['tool'].tolist(),
-                    "y": filtered_data['error_perc'].tolist(),
-                }
-
-            sel_tool.change(fn=update_tool_plot, inputs=sel_tool, outputs=plot_tool_error)
-            sel_week.change(fn=update_week_plot, inputs=sel_week, outputs=plot_week_error)
-            
-            with gr.Row():
-                plot_tool_error.render()
-            with gr.Row():
-                plot_week_error.render()
-                
-        with gr.TabItem("ℹ️ About"):
-            with gr.Accordion("About the Benchmark", open=False):
-                gr.Markdown("This app shows the actual performance of Olas Predict tools on the live market.")
-
-demo.queue(default_concurrency_limit=40).launch()

app.py

@@ -1,7 +1,30 @@
 import gradio as gr
 import pandas as pd
+from tabs.trades import (
+    prepare_trades, 
+    get_overall_trades, 
+    get_overall_winning_trades,
+    plot_trades_by_week,
+    plot_winning_trades_by_week,
+    plot_trade_details  
+)
+from tabs.tool_win import (
+    get_tool_winning_rate, 
+    get_overall_winning_rate,
+    plot_winning_trades,
+    plot_winning_plot_by_tool
+)
+from tabs.error import (
+    get_error_data, 
+    get_error_data_overall,
+    plot_error_data,
+    plot_tool_error_data,
+    plot_week_error_data
+)
 
-tools = pd.read_csv("./data/tools.csv")
+tools_df = pd.read_csv("./data/tools.csv")
+trades_df = pd.read_csv("./data/all_trades_profitability.csv")
+trades_df = prepare_trades(trades_df)
 
 demo = gr.Blocks()
 
@@ -19,78 +42,195 @@ INC_TOOLS = [
     'prediction-request-reasoning-claude'
 ]
 
-def set_error(row):
-    if row.error not in [True, False]:
-        if not row.prompt_response:
-            return True
-        return False
-    return row.error
-
-def get_error_data():
-    tools_inc = tools[tools['tool'].isin(INC_TOOLS)]
-    tools_inc['error'] = tools_inc.apply(set_error, axis=1)
-    error = tools_inc.groupby(['tool', 'request_month_year_week', 'error']).size().unstack().fillna(0).reset_index()
-    error['error_perc'] = (error[True] / (error[False] + error[True])) * 100
-    error['total_requests'] = error[False] + error[True]
-    return error
-
-def get_error_data_all(error):
-    error_total = error.groupby('request_month_year_week').agg({'total_requests': 'sum', False: 'sum', True: 'sum'}).reset_index()
-    error_total['error_perc'] = (error_total[True] / error_total['total_requests']) * 100
-    error_total.columns = error_total.columns.astype(str)
-    error_total['error_perc'] = error_total['error_perc'].apply(lambda x: round(x, 4))
-    return error_total
-
-error = get_error_data()
-error_all = get_error_data_all(error)
+
+# TOOLS DATA
+error_df = get_error_data(
+    tools_df=tools_df,
+    inc_tools=INC_TOOLS
+)
+error_overall_df = get_error_data_overall(
+    error_df=error_df
+)
+winning_rate_df = get_tool_winning_rate(
+    tools_df=tools_df, 
+    inc_tools=INC_TOOLS
+)
+winning_rate_all_df = get_overall_winning_rate(
+    wins_df=winning_rate_df
+)
+trades_count_df = get_overall_trades(
+    trades_df=trades_df
+)
+trades_winning_rate_df = get_overall_winning_trades(
+    trades_df=trades_df
+)
 
 with demo:
     gr.HTML("<h1>Olas Predict Actual Performance</h1>")
     gr.Markdown("This app shows the actual performance of Olas Predict tools on the live market.")
 
     with gr.Tabs():
-        with gr.TabItem("🔥 Error Dashboard"):
+        with gr.TabItem("🔥Trades Dashboard"):
+            with gr.Row():
+                gr.Markdown("# Plot of number of trades by week")
+            with gr.Row():
+                plot_trades_by_week = plot_trades_by_week(
+                    trades_df=trades_count_df
+                )
+            with gr.Row():
+                gr.Markdown("# Plot of winning trades by week")
+            with gr.Row():
+                plot_winning_trades_by_week = plot_winning_trades_by_week(
+                    trades_df=trades_winning_rate_df
+                )
+            with gr.Row():
+                gr.Markdown("# Plot of trade details")
+            with gr.Row():
+                trade_details_selector = gr.Dropdown(
+                    label="Select a trade", 
+                    choices=[
+                        "mech calls",
+                        "collateral amount",
+                        "earnings",
+                        "net earnings",
+                        "ROI"
+                    ],
+                    value="mech calls"
+                )
+            with gr.Row():
+                trade_details_plot = plot_trade_details(
+                    trade_detail="mech calls",
+                    trades_df=trades_df
+                )
+            
+            def update_trade_details(trade_detail):
+                return plot_trade_details(
+                    trade_detail=trade_detail,
+                    trades_df=trades_df
+                )
+
+            trade_details_selector.change(
+                update_trade_details, 
+                inputs=trade_details_selector, 
+                outputs=trade_details_plot
+            )
+
+            with gr.Row():
+                trade_details_selector
+            with gr.Row():
+                trade_details_plot
+
+        with gr.TabItem("🚀 Tool Winning Dashboard"):
+            with gr.Row():
+                gr.Markdown("# Plot showing overall winning rate")
+
+            with gr.Row():
+                winning_selector = gr.Dropdown(
+                    label="Select Metric", 
+                    choices=['losses', 'wins', 'total_request', 'win_perc'], 
+                    value='win_perc',
+                )
+
+            with gr.Row():
+                winning_plot = plot_winning_trades(
+                    wins_df=winning_rate_all_df,
+                    winning_selector="win_perc"
+                )
+
+            def update_winning_plot(winning_selector):
+                return plot_winning_trades(
+                    wins_df=winning_rate_all_df,
+                    winning_selector=winning_selector
+                )
+
+            winning_selector.change(
+                plot_winning_trades, 
+                inputs=winning_selector, 
+                outputs=winning_plot
+            )
+
+            with gr.Row():
+                winning_selector
+            with gr.Row():
+                winning_plot
+
+            with gr.Row():
+                gr.Markdown("# Plot showing winning rate by tool")
+            
+            with gr.Row():
+                sel_tool = gr.Dropdown(
+                    label="Select a tool", 
+                    choices=INC_TOOLS, 
+                    value=INC_TOOLS[0]
+                )
+
+            with gr.Row():
+                plot_tool_win_rate = plot_winning_plot_by_tool(
+                    wins_df=winning_rate_df,
+                    tool=INC_TOOLS[0]
+                )
+
+            def update_tool_win_plot(tool):
+                return plot_winning_plot_by_tool(
+                    wins_df=winning_rate_df,
+                    tool=tool
+                )
+
+            sel_tool.change(
+                update_tool_win_plot, 
+                inputs=sel_tool, 
+                outputs=plot_tool_win_rate
+            )
+
+            with gr.Row():
+                sel_tool
+            with gr.Row():
+                plot_tool_win_rate
+
+        with gr.TabItem("🏥 Tool Error Dashboard"):
             with gr.Row():
                 gr.Markdown("# Plot showing overall error")
             with gr.Row():
-                # plot 
-                with gr.Column():
-                    gr.BarPlot(
-                        value=error_all,
-                        x="request_month_year_week",
-                        y="error_perc",
-                        title="Error Percentage",
-                        x_title="Week",
-                        y_title="Error Percentage",
-                        height=800,
-                        show_label=True,
-                        interactive=True,
-                        show_actions_button=True,
-                        tooltip=["request_month_year_week", "error_perc"]
-                    )
+                plot_error_data(
+                    error_all_df=error_overall_df
+                )
             with gr.Row():
                 gr.Markdown("# Plot showing error by tool")
-
             with gr.Row():
-                sel_tool = gr.Dropdown(label="Select a tool", choices=INC_TOOLS, value=INC_TOOLS[0])
+                sel_tool = gr.Dropdown(
+                    label="Select a tool", 
+                    choices=INC_TOOLS, 
+                    value=INC_TOOLS[0]
+                )
 
             with gr.Row():
-                plot_tool_error = gr.BarPlot(
-                    title="Error Percentage", 
-                    x_title="Week", 
-                    y_title="Error Percentage", 
-                    show_label=True,
-                    interactive=True,
-                    show_actions_button=True,
-                    tooltip=["request_month_year_week", "error_perc"],
-                    width=800
+                plot_tool_error = plot_tool_error_data(
+                    error_df=error_df,
+                    tool=INC_TOOLS[0]
+                )
+
+
+            def update_tool_error_plot(tool):
+                return plot_tool_error_data(
+                    error_df=error_df,
+                    tool=tool
                 )
 
+            sel_tool.change(
+                update_tool_error_plot, 
+                inputs=sel_tool, 
+                outputs=plot_tool_error
+            )
+            with gr.Row():
+                sel_tool
+            with gr.Row():
+                plot_tool_error
+
             with gr.Row():
                 gr.Markdown("# Plot showing error by week")
 
             with gr.Row():
-                choices = error['request_month_year_week'].unique().tolist()
+                choices = error_overall_df['request_month_year_week'].unique().tolist()
                 # sort the choices by the latest week to be on the top
                 choices = sorted(choices)
                 sel_week = gr.Dropdown(
@@ -100,52 +240,19 @@ with demo:
                     )
 
             with gr.Row():
-                plot_week_error = gr.BarPlot(
-                    title="Error Percentage", 
-                    x_title="Tool", 
-                    y_title="Error Percentage", 
-                    show_label=True,
-                    interactive=True,
-                    show_actions_button=True,
-                    tooltip=["tool", "error_perc"],
-                    width=800
-                )
-
-
-            def update_tool_plot(selected_tool):
-                filtered_data = error[error['tool'] == selected_tool]
-                # convert column name to string
-                filtered_data.columns = filtered_data.columns.astype(str)
-                # convert error_perc to 4 decimal place
-                filtered_data['error_perc'] = filtered_data['error_perc'].apply(lambda x: round(x, 4))
-                update = gr.LinePlot(
-                    title="Error Percentage", 
-                    x_title="Week", 
-                    y_title="Error Percentage", 
-                    x="request_month_year_week", 
-                    y="error_perc",
-                    value=filtered_data
-                )
-                return update
-
-            def update_week_plot(selected_week):
-                filtered_data = error[error['request_month_year_week'] == selected_week]
-                # convert column name to string
-                filtered_data.columns = filtered_data.columns.astype(str)
-                # convert error_perc to 4 decimal place
-                filtered_data['error_perc'] = filtered_data['error_perc'].apply(lambda x: round(x, 4))
-                update = gr.BarPlot(
-                    title="Error Percentage", 
-                    x_title="Tool", 
-                    y_title="Error Percentage", 
-                    x="tool", 
-                    y="error_perc",
-                    value=filtered_data
-                )
-                return update
-
-            sel_tool.change(update_tool_plot, inputs=sel_tool, outputs=plot_tool_error)
-            sel_week.change(update_week_plot, inputs=sel_week, outputs=plot_week_error)
+                plot_week_error = plot_week_error_data(
+                    error_df=error_df,
+                    week=choices[-1]
+                )
+
+            def update_week_error_plot(selected_week):
+                return plot_week_error_data(
+                    error_df=error_df,
+                    week=selected_week
+                )
+
+            sel_tool.change(update_tool_error_plot, inputs=sel_tool, outputs=plot_tool_error)
+            sel_week.change(update_week_error_plot, inputs=sel_week, outputs=plot_week_error)
 
             with gr.Row():
                 sel_tool

data/all_trades_profitability.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:28ee508150a1cba56c9439d0cbfcf4871cb9f32f0792eb1d4dd7bca95af1e903
-size 28328169
+oid sha256:866a83eac6c603f435ee960b0da2570ced109438ee73e13a525b06a3d7baa133
+size 28938394

data/delivers.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0dafbbf73918de11435cbeaee7196ab0f37a18b06656a0c5325b1fa86be98b2c
-size 1121772123
+oid sha256:04f73cf0443fc8e91dd4b2e5188aee00f06ccc89d3977bf8e57063076ca91f51
+size 1270000369

data/fpmmTrades.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3a16a49dac94891d4438ea4eba6a52d6ef00f2985bbcc0e41daeb6f8557f5536
-size 62639698
+oid sha256:1e4600c2925a707bc882fda67612d03e28903e11947fe56f3e594f575f437d20
+size 64196881

data/fpmms.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d7933c45ab45cf377b55dbdc49f413ede81a7582cd843717c70cdd71f8fa7b74
-size 391125
+oid sha256:721b874d94ebb1a83456f75b911f79fd654971c2150976911968b27790ed7f84
+size 399415

data/requests.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:70d06d62c1fe5dd50fe5c7e3066413e843eb536cc51f08325fd85570b8255007
-size 124945839
+oid sha256:db71f7e4cebe1e68eb280615d4331f3fe6a8732d94c29920b7b485f048631b7a
+size 129156993

data/summary_profitability.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d4769b2c800f4a3c655de8a5673070c5be00ce5733798cc9a745cc5df2f961a6
-size 46612
+oid sha256:1a999ed3c31ae1ee71da379e0840995584491457db4ca7250ca2e7f9b55c3869
+size 48242

data/tools.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4045250b8b4ec74ca3d37ce94208665c1ea09042b6681106615f0773ce46aee0
-size 1211219315
+oid sha256:35f76795539604c1c50f70d161c217c32c0fa04bbbd94ee29f5717b782c6863f
+size 1363028261

tabs/error.py

@@ -0,0 +1,77 @@
+import pandas as pd
+import gradio as gr
+
+def set_error(row):
+    if row.error not in [True, False]:
+        if not row.prompt_response:
+            return True
+        return False
+    return row.error
+
+def get_error_data(tools_df, inc_tools):
+    tools_inc = tools_df[tools_df['tool'].isin(inc_tools)]
+    tools_inc['error'] = tools_inc.apply(set_error, axis=1)
+    error = tools_inc.groupby(['tool', 'request_month_year_week', 'error']).size().unstack().fillna(0).reset_index()
+    error['error_perc'] = (error[True] / (error[False] + error[True])) * 100
+    error['total_requests'] = error[False] + error[True]
+    return error
+
+def get_error_data_overall(error_df):
+    error_total = error_df.groupby('request_month_year_week').agg({'total_requests': 'sum', False: 'sum', True: 'sum'}).reset_index()
+    error_total['error_perc'] = (error_total[True] / error_total['total_requests']) * 100
+    error_total.columns = error_total.columns.astype(str)
+    error_total['error_perc'] = error_total['error_perc'].apply(lambda x: round(x, 4))
+    return error_total
+
+def plot_error_data(error_all_df):
+    return gr.BarPlot(
+        value=error_all_df,
+        x="request_month_year_week",
+        y="error_perc",
+        title="Error Percentage",
+        x_title="Week",
+        y_title="Error Percentage",
+        height=800,
+        show_label=True,
+        interactive=True,
+        show_actions_button=True,
+        tooltip=["request_month_year_week", "error_perc"]
+    )
+
+def plot_tool_error_data(error_df, tool):
+    error_tool = error_df[error_df['tool'] == tool]
+    error_tool.columns = error_tool.columns.astype(str)
+    error_tool['error_perc'] = error_tool['error_perc'].apply(lambda x: round(x, 4))
+                
+    return gr.BarPlot(
+            title="Error Percentage", 
+            x_title="Week", 
+            y_title="Error Percentage", 
+            show_label=True,
+            interactive=True,
+            show_actions_button=True,
+            tooltip=["request_month_year_week", "error_perc"],
+            width=800,
+            value=error_tool,
+            x="request_month_year_week",
+            y="error_perc"
+    )
+
+def plot_week_error_data(error_df, week):
+    error_week = error_df[error_df['request_month_year_week'] == week]
+    error_week.columns = error_week.columns.astype(str)
+    error_week['error_perc'] = error_week['error_perc'].apply(lambda x: round(x, 4))
+    return gr.BarPlot(
+        value=error_week,
+        x="tool",
+        y="error_perc",
+        title="Error Percentage",
+        x_title="Tool",
+        y_title="Error Percentage",
+        height=800,
+        show_label=True,
+        interactive=True,
+        show_actions_button=True,
+        tooltip=["tool", "error_perc"]
+    )
+

tabs/tool_win.py

@@ -0,0 +1,73 @@
+import pandas as pd
+import gradio as gr
+
+def set_error(row):
+    if row.error not in [True, False]:
+        if not row.prompt_response:
+            return True
+        return False
+    return row.error
+
+
+def get_tool_winning_rate(tools_df, inc_tools):
+    tools_inc = tools_df[tools_df['tool'].isin(inc_tools)]
+    tools_inc['error'] = tools_inc.apply(set_error, axis=1)
+    tools_non_error = tools_inc[tools_inc['error'] != True]
+    tools_non_error['currentAnswer'].replace('no', 'No', inplace=True)
+    tools_non_error['currentAnswer'].replace('yes', 'Yes', inplace=True)
+    tools_non_error = tools_non_error[tools_non_error['currentAnswer'].isin(['Yes', 'No'])]
+    tools_non_error = tools_non_error[tools_non_error['vote'].isin(['Yes', 'No'])]
+    tools_non_error['win'] = tools_non_error['currentAnswer'] == tools_non_error['vote']
+    tools_non_error['win'] = tools_non_error['win'].astype(int)
+    tools_non_error.columns = tools_non_error.columns.astype(str)
+    wins = tools_non_error.groupby(['tool', 'request_month_year_week', 'win']).size().unstack().fillna(0)
+    wins['win_perc'] = (wins[1] / (wins[0] + wins[1]))*100
+    wins.reset_index(inplace=True)
+    wins['total_request'] = wins[0] + wins[1]
+    wins.columns = wins.columns.astype(str)
+    return wins
+
+
+def get_overall_winning_rate(wins_df):
+    overall_wins = wins_df.groupby('request_month_year_week').agg({
+        "0": 'sum',
+        "1": 'sum',
+        "win_perc": 'mean',
+        "total_request": 'sum'
+    }).rename(columns={"0": 'losses', "1": 'wins'}).reset_index()
+    return overall_wins
+
+
+def plot_winning_trades(
+    wins_df,
+    winning_selector="win_perc"
+    ):
+    return gr.BarPlot(
+        title="Winning Rate", 
+        x_title="Date", 
+        y_title=winning_selector,
+        show_label=True,
+        interactive=True,
+        show_actions_button=True,
+        tooltip=["request_month_year_week", winning_selector],
+        width=800,
+        value=wins_df,
+        x="request_month_year_week",
+        y=winning_selector
+    )
+
+
+def plot_winning_plot_by_tool(wins_df, tool):
+    return gr.BarPlot(
+                title="Winning Rate", 
+                x_title="Week", 
+                y_title="Winning Rate", 
+                x="request_month_year_week", 
+                y="win_perc",
+                value=wins_df[wins_df['tool'] == tool],
+                width=800,
+                show_label=True,
+                interactive=True,
+                show_actions_button=True,
+                tooltip=["request_month_year_week", "win_perc"]
+            )

tabs/trades.py

@@ -0,0 +1,174 @@
+import gradio as gr
+import pandas as pd
+
+
+def prepare_trades(trades_df):
+    trades_df['creation_timestamp'] = pd.to_datetime(trades_df['creation_timestamp'])
+    trades_df['month_year'] = trades_df['creation_timestamp'].dt.to_period('M').astype(str)
+    trades_df['month_year_week'] = trades_df['creation_timestamp'].dt.to_period('W').astype(str)
+    trades_df['winning_trade'] = trades_df['winning_trade'].astype(int)
+    return trades_df
+
+
+def get_overall_trades(trades_df):
+    trades_count = trades_df.groupby('month_year_week').size().reset_index()
+    trades_count.columns = trades_count.columns.astype(str)
+    trades_count.rename(columns={'0': 'trades'}, inplace=True)
+    return trades_count
+
+def get_overall_winning_trades(trades_df):
+    winning_trades = trades_df.groupby(['month_year_week'])['winning_trade'].sum() / trades_df.groupby(['month_year_week'])['winning_trade'].count() * 100
+    # winning_trades is a series, give it a dataframe
+    winning_trades = winning_trades.reset_index()
+    winning_trades.columns = winning_trades.columns.astype(str)
+    winning_trades.columns = ['month_year_week', 'winning_trade']
+    return winning_trades
+
+def plot_trade_details(trade_detail, trades_df):
+    if trade_detail == "mech calls":
+        # this is to filter out the data before 2023-09-01
+        trades_filtered = trades_df[trades_df["creation_timestamp"] >"2023-09-01"]
+        trades_filtered = trades_filtered.groupby("month_year_week")["num_mech_calls"].quantile([0.25, 0.5, 0.75]).unstack()
+        trades_filtered.columns = trades_filtered.columns.astype(str)
+        trades_filtered.reset_index(inplace=True)
+        trades_filtered.columns = [
+            "month_year_week",
+            "25th_percentile",
+            "50th_percentile",
+            "75th_percentile"
+        ]
+        # reformat the data as percentile, date, value
+        trades_filtered = trades_filtered.melt(id_vars=["month_year_week"], var_name="percentile", value_name="mech_calls")
+
+        return gr.LinePlot(
+            value=trades_filtered,
+            x="month_year_week",
+            y="mech_calls",
+            color="percentile",
+            show_label=True,
+            interactive=True,
+            show_actions_button=True,
+            tooltip=["month_year_week", "percentile", "mech_calls"]
+        )
+    
+    if trade_detail == "collateral amount":
+        trades_filtered = trades_df[trades_df["creation_timestamp"] >"2023-09-01"]
+        trades_filtered = trades_filtered.groupby("month_year_week")["collateral_amount"].quantile([0.25, 0.5, 0.75]).unstack()
+        trades_filtered.columns = trades_filtered.columns.astype(str)
+        trades_filtered.reset_index(inplace=True)
+        trades_filtered.columns = [
+            "month_year_week",
+            "25th_percentile",
+            "50th_percentile",
+            "75th_percentile"
+        ]
+        # reformat the data as percentile, date, value
+        trades_filtered = trades_filtered.melt(id_vars=["month_year_week"], var_name="percentile", value_name="collateral_amount")
+
+        return gr.LinePlot(
+            value=trades_filtered,
+            x="month_year_week",
+            y="collateral_amount",
+            color="percentile",
+            show_label=True,
+            interactive=True,
+            show_actions_button=True,
+            tooltip=["month_year_week", "percentile", "collateral_amount"]
+        )
+
+    if trade_detail == "earnings":
+        trades_filtered = trades_df[trades_df["creation_timestamp"] >"2023-09-01"]
+        trades_filtered = trades_filtered.groupby("month_year_week")["earnings"].quantile([0.25, 0.5, 0.75]).unstack()
+        trades_filtered.columns = trades_filtered.columns.astype(str)
+        trades_filtered.reset_index(inplace=True)
+        trades_filtered.columns = [
+            "month_year_week",
+            "25th_percentile",
+            "50th_percentile",
+            "75th_percentile"
+        ]
+        # reformat the data as percentile, date, value
+        trades_filtered = trades_filtered.melt(id_vars=["month_year_week"], var_name="percentile", value_name="earnings")
+
+        return gr.LinePlot(
+            value=trades_filtered,
+            x="month_year_week",
+            y="earnings",
+            color="percentile",
+            show_label=True,
+            interactive=True,
+            show_actions_button=True,
+            tooltip=["month_year_week", "percentile", "earnings"]
+        )
+    
+    if trade_detail == "net earnings":
+        trades_filtered = trades_df[trades_df["creation_timestamp"] >"2023-09-01"]
+        trades_filtered = trades_filtered.groupby("month_year_week")["net_earnings"].quantile([0.25, 0.5, 0.75]).unstack()
+        trades_filtered.columns = trades_filtered.columns.astype(str)
+        trades_filtered.reset_index(inplace=True)
+        trades_filtered.columns = [
+            "month_year_week",
+            "25th_percentile",
+            "50th_percentile",
+            "75th_percentile"
+        ]
+        # reformat the data as percentile, date, value
+        trades_filtered = trades_filtered.melt(id_vars=["month_year_week"], var_name="percentile", value_name="net_earnings")
+
+        return gr.LinePlot(
+            value=trades_filtered,
+            x="month_year_week",
+            y="net_earnings",
+            color="percentile",
+            show_label=True,
+            interactive=True,
+            show_actions_button=True,
+            tooltip=["month_year_week", "percentile", "net_earnings"]
+        )        
+    
+    if trade_detail == "ROI":
+        trades_filtered = trades_df[trades_df["creation_timestamp"] >"2023-09-01"]
+        trades_filtered = trades_filtered.groupby("month_year_week")["roi"].quantile([0.25, 0.5, 0.75]).unstack()
+        trades_filtered.columns = trades_filtered.columns.astype(str)
+        trades_filtered.reset_index(inplace=True)
+        trades_filtered.columns = [
+            "month_year_week",
+            "25th_percentile",
+            "50th_percentile",
+            "75th_percentile"
+        ]
+        # reformat the data as percentile, date, value
+        trades_filtered = trades_filtered.melt(id_vars=["month_year_week"], var_name="percentile", value_name="ROI")
+
+        return gr.LinePlot(
+            value=trades_filtered,
+            x="month_year_week",
+            y="ROI",
+            color="percentile",
+            show_label=True,
+            interactive=True,
+            show_actions_button=True,
+            tooltip=["month_year_week", "percentile", "ROI"]
+        )    
+    
+def plot_trades_by_week(trades_df):
+    return gr.BarPlot(
+        value=trades_df,
+        x="month_year_week",
+        y="trades",
+        show_label=True,
+        interactive=True,
+        show_actions_button=True,
+        tooltip=["month_year_week", "trades"]
+    )
+
+def plot_winning_trades_by_week(trades_df):
+    return gr.BarPlot(
+        value=trades_df,
+        x="month_year_week",
+        y="winning_trade",
+        show_label=True,
+        interactive=True,
+        show_actions_button=True,
+        tooltip=["month_year_week", "winning_trade"]
+    )