new error graphs with markets

app.py

@@ -19,8 +19,6 @@ from tabs.metrics import (
     default_trade_metric,
     default_tool_metric,
     plot_trade_metrics,
-    WIDTH,
-    HEIGHT,
     get_trade_metrics_text,
 )
 
@@ -44,11 +42,11 @@ from tabs.invalid_markets import (
 )
 
 from tabs.error import (
-    get_error_data,
-    get_error_data_overall,
-    plot_error_data,
-    plot_tool_error_data,
-    plot_week_error_data,
+    plot_week_error_data_by_market,
+    plot_error_data_by_market,
+    get_error_data_by_market,
+    get_error_data_overall_by_market,
+    plot_tool_error_data_by_market,
 )
 from tabs.about import about_olas_predict, about_this_dashboard
 
@@ -169,9 +167,10 @@ tools_df, trades_df, tools_accuracy_info, invalid_trades = prepare_data()
 
 
 demo = gr.Blocks()
+# preparing data for the errors
+error_by_markets = get_error_data_by_market(tools_df=tools_df, inc_tools=INC_TOOLS)
+error_overall_by_markets = get_error_data_overall_by_market(error_df=error_by_markets)
 
-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_df = get_tool_winning_rate_by_market(tools_df, inc_tools=INC_TOOLS)
 # preparing data for the trades graph
 trades_count_df = get_overall_trades(trades_df=trades_df)
@@ -336,11 +335,6 @@ with demo:
             with gr.Row():
                 daily_trades = plot_daily_dist_invalid_trades(invalid_trades)
 
-            # with gr.Row():
-            #     gr.Markdown("# Ratio of invalid trades per market")
-            # with gr.Row():
-            #     plot_ratio_invalid_trades_per_market(invalid_trades)
-
             with gr.Row():
                 gr.Markdown("# Top markets with invalid trades")
             with gr.Row():
@@ -355,7 +349,9 @@ with demo:
             with gr.Row():
                 gr.Markdown("# All tools errors")
             with gr.Row():
-                error_overall_plot = plot_error_data(error_all_df=error_overall_df)
+                error_overall_plot = plot_error_data_by_market(
+                    error_all_df=error_overall_by_markets
+                )
             with gr.Row():
                 gr.Markdown("# Error percentage per tool")
             with gr.Row():
@@ -364,12 +360,14 @@ with demo:
                 )
 
             with gr.Row():
-                tool_error_plot = plot_tool_error_data(
-                    error_df=error_df, tool=INC_TOOLS[0]
+                tool_error_plot = plot_tool_error_data_by_market(
+                    error_df=error_by_markets, tool=INC_TOOLS[0]
                 )
 
             def update_tool_error_plot(tool):
-                return plot_tool_error_data(error_df=error_df, tool=tool)
+                return plot_tool_error_data_by_market(
+                    error_df=error_by_markets, tool=tool
+                )
 
             sel_tool.change(
                 update_tool_error_plot, inputs=sel_tool, outputs=tool_error_plot
@@ -383,7 +381,11 @@ with demo:
                 gr.Markdown("# Tools distribution of errors per week")
 
             with gr.Row():
-                choices = error_overall_df["request_month_year_week"].unique().tolist()
+                choices = (
+                    error_overall_by_markets["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(
@@ -391,12 +393,14 @@ with demo:
                 )
 
             with gr.Row():
-                week_error_plot = plot_week_error_data(
-                    error_df=error_df, week=choices[-1]
+                week_error_plot = plot_week_error_data_by_market(
+                    error_df=error_by_markets, week=choices[-1]
                 )
 
             def update_week_error_plot(selected_week):
-                return plot_week_error_data(error_df=error_df, week=selected_week)
+                return plot_week_error_data_by_market(
+                    error_df=error_by_markets, week=selected_week
+                )
 
             sel_tool.change(
                 update_tool_error_plot, inputs=sel_tool, outputs=tool_error_plot

tabs/error.py

@@ -1,6 +1,8 @@
 import pandas as pd
 import gradio as gr
 from typing import List
+import plotly.express as px
+from tabs.tool_win import sort_key
 
 
 HEIGHT = 600
@@ -22,6 +24,25 @@ def get_error_data(tools_df: pd.DataFrame, inc_tools: List[str]) -> pd.DataFrame
     return error
 
 
+def get_error_data_by_market(
+    tools_df: pd.DataFrame, inc_tools: List[str]
+) -> pd.DataFrame:
+    """Gets the error data for the given tools and calculates the error percentage."""
+    tools_inc = tools_df[tools_df["tool"].isin(inc_tools)]
+    error = (
+        tools_inc.groupby(
+            ["tool", "request_month_year_week", "market_creator", "error"], sort=False
+        )
+        .size()
+        .unstack()
+        .fillna(0)
+        .reset_index()
+    )
+    error["error_perc"] = (error[1] / (error[0] + error[1])) * 100
+    error["total_requests"] = error[0] + error[1]
+    return error
+
+
 def get_error_data_overall(error_df: pd.DataFrame) -> pd.DataFrame:
     """Gets the error data for the given tools and calculates the error percentage."""
     error_total = (
@@ -35,6 +56,19 @@ def get_error_data_overall(error_df: pd.DataFrame) -> pd.DataFrame:
     return error_total
 
 
+def get_error_data_overall_by_market(error_df: pd.DataFrame) -> pd.DataFrame:
+    """Gets the error data for the given tools and calculates the error percentage."""
+    error_total = (
+        error_df.groupby(["request_month_year_week", "market_creator"], sort=False)
+        .agg({"total_requests": "sum", 1: "sum", 0: "sum"})
+        .reset_index()
+    )
+    error_total["error_perc"] = (error_total[1] / 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: pd.DataFrame) -> gr.BarPlot:
     """Plots the error data for the given tools and calculates the error percentage."""
     return gr.BarPlot(
@@ -53,6 +87,44 @@ def plot_error_data(error_all_df: pd.DataFrame) -> gr.BarPlot:
     )
 
 
+def plot_error_data_by_market(error_all_df: pd.DataFrame) -> gr.Plot:
+
+    # Sort the unique values of request_month_year_week
+    sorted_categories = sorted(
+        error_all_df["request_month_year_week"].unique(), key=sort_key
+    )
+    # Create a categorical type with a specific order
+    error_all_df["request_month_year_week"] = pd.Categorical(
+        error_all_df["request_month_year_week"],
+        categories=sorted_categories,
+        ordered=True,
+    )
+
+    # Sort the DataFrame based on the new categorical column
+    error_all_df = error_all_df.sort_values("request_month_year_week")
+
+    fig = px.bar(
+        error_all_df,
+        x="request_month_year_week",
+        y="error_perc",
+        color="market_creator",
+        barmode="group",
+        color_discrete_sequence=["purple", "goldenrod", "darkgreen"],
+        category_orders={
+            "market_creator": ["pearl", "quickstart", "all"],
+            "request_month_year_week": sorted_categories,
+        },
+    )
+    fig.update_layout(
+        xaxis_title="Week",
+        yaxis_title="Error Percentage",
+        legend=dict(yanchor="top", y=0.5),
+    )
+    fig.update_layout(width=WIDTH, height=HEIGHT)
+    fig.update_xaxes(tickformat="%b %d\n%Y")
+    return gr.Plot(value=fig)
+
+
 def plot_tool_error_data(error_df: pd.DataFrame, tool: str) -> gr.BarPlot:
     """Plots the error data for the given tool."""
     error_tool = error_df[error_df["tool"] == tool]
@@ -62,7 +134,7 @@ def plot_tool_error_data(error_df: pd.DataFrame, tool: str) -> gr.BarPlot:
     return gr.BarPlot(
         title="Error Percentage",
         x_title="Week",
-        y_title="Error Percentage",
+        y_title="Error Percentage %",
         show_label=True,
         interactive=True,
         show_actions_button=True,
@@ -75,6 +147,47 @@ def plot_tool_error_data(error_df: pd.DataFrame, tool: str) -> gr.BarPlot:
     )
 
 
+def plot_tool_error_data_by_market(error_df: pd.DataFrame, tool: str) -> gr.Plot:
+    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))
+
+    # Sort the unique values of request_month_year_week
+    sorted_categories = sorted(
+        error_tool["request_month_year_week"].unique(), key=sort_key
+    )
+    # Create a categorical type with a specific order
+    error_tool["request_month_year_week"] = pd.Categorical(
+        error_tool["request_month_year_week"],
+        categories=sorted_categories,
+        ordered=True,
+    )
+
+    # Sort the DataFrame based on the new categorical column
+    error_tool = error_tool.sort_values("request_month_year_week")
+
+    fig = px.bar(
+        error_tool,
+        x="request_month_year_week",
+        y="error_perc",
+        color="market_creator",
+        barmode="group",
+        color_discrete_sequence=["purple", "goldenrod", "darkgreen"],
+        category_orders={
+            "market_creator": ["pearl", "quickstart", "all"],
+            "request_month_year_week": sorted_categories,
+        },
+    )
+    fig.update_layout(
+        xaxis_title="Week",
+        yaxis_title="Error Percentage %",
+        legend=dict(yanchor="top", y=0.5),
+    )
+    fig.update_layout(width=WIDTH, height=HEIGHT)
+    fig.update_xaxes(tickformat="%b %d\n%Y")
+    return gr.Plot(value=fig)
+
+
 def plot_week_error_data(error_df: pd.DataFrame, week: str) -> gr.BarPlot:
     """Plots the error data for the given week."""
     error_week = error_df[error_df["request_month_year_week"] == week]
@@ -94,3 +207,29 @@ def plot_week_error_data(error_df: pd.DataFrame, week: str) -> gr.BarPlot:
         height=HEIGHT,
         width=WIDTH,
     )
+
+
+def plot_week_error_data_by_market(error_df: pd.DataFrame, week: str) -> gr.Plot:
+    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))
+
+    fig = px.bar(
+        error_week,
+        x="tool",
+        y="error_perc",
+        color="market_creator",
+        barmode="group",
+        color_discrete_sequence=["purple", "goldenrod", "darkgreen"],
+        category_orders={
+            "market_creator": ["pearl", "quickstart", "all"],
+        },
+    )
+    fig.update_layout(
+        xaxis_title="Tool",
+        yaxis_title="Error Percentage %",
+        legend=dict(yanchor="top", y=0.5),
+    )
+    fig.update_layout(width=WIDTH, height=HEIGHT)
+    fig.update_xaxes(tickformat="%b %d\n%Y")
+    return gr.Plot(value=fig)