app.py

from datetime import datetime, timedelta
import gradio as gr
import pandas as pd
import duckdb
import logging
from tabs.trades import (
    prepare_trades,
    get_overall_trades,
    get_overall_by_market_trades,
    get_overall_winning_by_market_trades,
    integrated_plot_trades_per_market_by_week_v2,
    integrated_plot_winning_trades_per_market_by_week_v2,
)
from tabs.staking import plot_staking_trades_per_market_by_week

from tabs.metrics import (
    trade_metric_choices,
    tool_metric_choices,
    default_trade_metric,
    default_tool_metric,
    plot_trade_metrics,
    get_trade_metrics_text,
)

from tabs.tool_win import (
    prepare_tools,
    get_tool_winning_rate_by_market,
    integrated_plot_tool_winnings_overall_per_market_by_week,
    integrated_tool_winnings_by_tool_per_market,
)

from tabs.tool_accuracy import (
    plot_tools_weighted_accuracy_rotated_graph,
    plot_tools_accuracy_rotated_graph,
    compute_weighted_accuracy,
)

from tabs.invalid_markets import (
    plot_daily_dist_invalid_trades,
    plot_top_invalid_markets,
    plotly_daily_nr_invalid_markets,
)

from tabs.error import (
    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
from scripts.utils import INC_TOOLS


def get_logger():
    logger = logging.getLogger(__name__)
    logger.setLevel(logging.DEBUG)
    # stream handler and formatter
    stream_handler = logging.StreamHandler()
    stream_handler.setLevel(logging.DEBUG)
    formatter = logging.Formatter(
        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
    )
    stream_handler.setFormatter(formatter)
    logger.addHandler(stream_handler)
    return logger


logger = get_logger()


def get_last_one_month_data():
    """
    Get the last one month data from the tools.parquet file
    """
    logger.info("Getting last one month data")
    con = duckdb.connect(":memory:")
    one_months_ago = (datetime.now() - timedelta(days=60)).strftime("%Y-%m-%d")

    # Query to fetch data from all_trades_profitability.parquet
    query2 = f"""
    SELECT *
    FROM read_parquet('./data/all_trades_profitability.parquet')
    WHERE creation_timestamp >= '{one_months_ago}'
    """
    df2 = con.execute(query2).fetchdf()
    logger.info("Got last one month data from all_trades_profitability.parquet")

    query1 = f"""
    SELECT *
    FROM read_parquet('./data/tools.parquet')
    WHERE request_time >= '{one_months_ago}'
    """
    df1 = con.execute(query1).fetchdf()
    logger.info("Got last one month data from tools.parquet")

    con.close()

    return df1, df2


def get_all_data():
    """
    Get all data from the tools.parquet, tools_accuracy and trades parquet files
    """
    logger.info("Getting all data")

    con = duckdb.connect(":memory:")
    # Query to fetch invalid trades data
    query4 = f"""
    SELECT *
    FROM read_parquet('./data/invalid_trades.parquet')
    """
    df4 = con.execute(query4).fetchdf()

    # Query to fetch tools accuracy data
    query3 = f"""
    SELECT *
    FROM read_csv('./data/tools_accuracy.csv')
    """
    df3 = con.execute(query3).fetchdf()

    # Query to fetch data from all_trades_profitability.parquet
    query2 = f"""
    SELECT *
    FROM read_parquet('./data/all_trades_profitability.parquet')
    """
    df2 = con.execute(query2).fetchdf()
    logger.info("Got all data from all_trades_profitability.parquet")

    query1 = f"""
    SELECT *
    FROM read_parquet('./data/tools.parquet')
    """
    df1 = con.execute(query1).fetchdf()
    logger.info("Got all data from tools.parquet")

    con.close()

    return df1, df2, df3, df4


def prepare_data():
    """
    Prepare the data for the dashboard
    """
    tools_df, trades_df, tools_accuracy_info, invalid_trades = get_all_data()
    print(trades_df.info())

    tools_df = prepare_tools(tools_df)
    trades_df = prepare_trades(trades_df)

    tools_accuracy_info = compute_weighted_accuracy(tools_accuracy_info)
    print("weighted accuracy info")
    print(tools_accuracy_info.head())

    invalid_trades["creation_timestamp"] = pd.to_datetime(
        invalid_trades["creation_timestamp"]
    )
    invalid_trades["creation_date"] = invalid_trades["creation_timestamp"].dt.date

    # discovering outliers for ROI
    outliers = trades_df.loc[trades_df["roi"] >= 1000]
    if len(outliers) > 0:
        outliers.to_parquet("./data/outliers.parquet")
        trades_df = trades_df.loc[trades_df["roi"] < 1000]

    return tools_df, trades_df, tools_accuracy_info, invalid_trades


tools_df, trades_df, tools_accuracy_info, invalid_trades = prepare_data()
trades_df = trades_df.sort_values(by="creation_timestamp", ascending=True)

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)

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)
trades_by_market = get_overall_by_market_trades(trades_df=trades_df)
winning_trades_by_market = get_overall_winning_by_market_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("🔥 Weekly Trades Dashboard"):
            with gr.Row():
                gr.Markdown("# Trend of weekly trades")
            with gr.Row():
                trades_by_week = integrated_plot_trades_per_market_by_week_v2(
                    trades_df=trades_df
                )

            with gr.Row():
                with gr.Column(scale=1):
                    gr.Markdown(
                        "# Weekly percentage of winning for  🤖 Agent based trades"
                    )
                    agent_winning_trades = (
                        integrated_plot_winning_trades_per_market_by_week_v2(
                            trades_df=trades_df, trader_filter="agent"
                        )
                    )
                with gr.Column(scale=1):
                    gr.Markdown(
                        "# Weekly percentage of winning for Non-agent based trades"
                    )
                    non_agent_winning_trades = (
                        integrated_plot_winning_trades_per_market_by_week_v2(
                            trades_df=trades_df, trader_filter="non_agent"
                        )
                    )

            def update_trade_details(trade_detail, trade_details_plot):
                new_plot = plot_trade_metrics(
                    metric_name=trade_detail,
                    trades_df=trades_df,
                )
                return new_plot

            with gr.Row():
                gr.Markdown("# ⚖️ Weekly trading metrics for all trades")
            with gr.Row():
                trade_details_selector = gr.Dropdown(
                    label="Select a trade metric",
                    choices=trade_metric_choices,
                    value=default_trade_metric,
                )

            with gr.Row():
                with gr.Column(scale=3):
                    trade_details_plot = plot_trade_metrics(
                        metric_name=default_trade_metric,
                        trades_df=trades_df,
                    )
                with gr.Column(scale=1):
                    trade_details_text = get_trade_metrics_text()

            trade_details_selector.change(
                update_trade_details,
                inputs=[trade_details_selector, trade_details_plot],
                outputs=[trade_details_plot],
            )

            # Agentic traders graph
            with gr.Row():
                gr.Markdown("# Weekly trading metrics for trades coming from Agents 🤖")
            with gr.Row():
                trade_a_details_selector = gr.Dropdown(
                    label="Select a trade metric",
                    choices=trade_metric_choices,
                    value=default_trade_metric,
                )

            with gr.Row():
                with gr.Column(scale=3):
                    a_trade_details_plot = plot_trade_metrics(
                        metric_name=default_trade_metric,
                        trades_df=trades_df,
                        trader_filter="agent",
                    )
                with gr.Column(scale=1):
                    trade_details_text = get_trade_metrics_text()

            def update_a_trade_details(trade_detail, trade_details_plot):
                new_a_plot = plot_trade_metrics(
                    metric_name=trade_detail,
                    trades_df=trades_df,
                    trader_filter="agent",
                )
                return new_a_plot

            trade_a_details_selector.change(
                update_a_trade_details,
                inputs=[trade_a_details_selector, a_trade_details_plot],
                outputs=[a_trade_details_plot],
            )

            # Non-agentic traders graph
            with gr.Row():
                gr.Markdown(
                    "# Weekly trading metrics for trades coming from Non-agents"
                )
            with gr.Row():
                trade_na_details_selector = gr.Dropdown(
                    label="Select a trade metric",
                    choices=trade_metric_choices,
                    value=default_trade_metric,
                )

            with gr.Row():
                with gr.Column(scale=3):
                    na_trade_details_plot = plot_trade_metrics(
                        metric_name=default_trade_metric,
                        trades_df=trades_df,
                        trader_filter="non_agent",
                    )
                with gr.Column(scale=1):
                    trade_details_text = get_trade_metrics_text()

            def update_na_trade_details(trade_detail, trade_details_plot):
                new_a_plot = plot_trade_metrics(
                    metric_name=trade_detail,
                    trades_df=trades_df,
                    trader_filter="non_agent",
                )
                return new_a_plot

            trade_na_details_selector.change(
                update_na_trade_details,
                inputs=[trade_na_details_selector, na_trade_details_plot],
                outputs=[na_trade_details_plot],
            )

        with gr.TabItem("🔒 Staking traders"):
            with gr.Row():
                gr.Markdown("# Trades conducted at the Pearl markets")
            with gr.Row():
                staking_trades_by_week = plot_staking_trades_per_market_by_week(
                    trades_df=trades_df, market_creator="pearl"
                )
            with gr.Row():
                gr.Markdown("# Trades conducted at the Quickstart markets")
            with gr.Row():
                staking_trades_by_week = plot_staking_trades_per_market_by_week(
                    trades_df=trades_df, market_creator="quickstart"
                )
            with gr.Row():
                gr.Markdown("# Trades conducted irrespective of the market")
            with gr.Row():
                staking_trades_by_week = plot_staking_trades_per_market_by_week(
                    trades_df=trades_df, market_creator="all"
                )
        with gr.TabItem("🚀 Tool Winning Dashboard"):
            with gr.Row():
                gr.Markdown("# All tools winning performance")

            with gr.Row():
                winning_selector = gr.Dropdown(
                    label="Select the tool metric",
                    choices=list(tool_metric_choices.keys()),
                    value=default_tool_metric,
                )

            with gr.Row():
                # plot_tool_metrics
                winning_plot = integrated_plot_tool_winnings_overall_per_market_by_week(
                    winning_df=winning_df,
                    winning_selector=default_tool_metric,
                )

            def update_tool_winnings_overall_plot(winning_selector):
                return integrated_plot_tool_winnings_overall_per_market_by_week(
                    winning_df=winning_df, winning_selector=winning_selector
                )

            winning_selector.change(
                update_tool_winnings_overall_plot,
                inputs=winning_selector,
                outputs=winning_plot,
            )

            with gr.Row():
                winning_selector
            with gr.Row():
                winning_plot

            with gr.Row():
                gr.Markdown("# Winning performance by each tool")

            with gr.Row():
                sel_tool = gr.Dropdown(
                    label="Select a tool", choices=INC_TOOLS, value=INC_TOOLS[0]
                )

            with gr.Row():
                tool_winnings_by_tool_plot = (
                    integrated_tool_winnings_by_tool_per_market(
                        wins_df=winning_df, tool=INC_TOOLS[0]
                    )
                )

            def update_tool_winnings_by_tool_plot(tool):
                return integrated_tool_winnings_by_tool_per_market(
                    wins_df=winning_df, tool=tool
                )

            sel_tool.change(
                update_tool_winnings_by_tool_plot,
                inputs=sel_tool,
                outputs=tool_winnings_by_tool_plot,
            )

            with gr.Row():
                sel_tool
            with gr.Row():
                tool_winnings_by_tool_plot
        with gr.TabItem("🎯 Tool Accuracy Dashboard"):
            with gr.Row():
                gr.Markdown("# Tools accuracy ranking")
            with gr.Row():
                gr.Markdown(
                    "The data used for this metric is from the past two months. This accuracy is computed based on right answers from the total requests received."
                )

            with gr.Row():
                _ = plot_tools_accuracy_rotated_graph(tools_accuracy_info)

            with gr.Row():
                gr.Markdown("# Weighted accuracy ranking per tool")
            with gr.Row():
                gr.Markdown(
                    "This metric is an approximation to the real metric used by the trader since some parameters are only dynamically generated."
                )
            with gr.Row():
                gr.Markdown(
                    "The data used for this metric is from the past two months. This metric is computed using both the tool accuracy and the volume of requests received by the tool. The minimum value of this custom metric is 0 and the maximum value is 1. The higher the better is the tool."
                )
            with gr.Row():
                _ = plot_tools_weighted_accuracy_rotated_graph(tools_accuracy_info)

        with gr.TabItem("⛔ Invalid Markets Dashboard"):
            with gr.Row():
                gr.Markdown("# Daily distribution of invalid trades")
            with gr.Row():
                daily_trades = plot_daily_dist_invalid_trades(invalid_trades)

            with gr.Row():
                gr.Markdown("# Top markets with invalid trades")
            with gr.Row():
                top_invalid_markets = plot_top_invalid_markets(invalid_trades)

            with gr.Row():
                gr.Markdown("# Daily distribution of invalid markets")
            with gr.Row():
                invalid_markets = plotly_daily_nr_invalid_markets(invalid_trades)

        with gr.TabItem("🏥 Tool Error Dashboard"):
            with gr.Row():
                gr.Markdown("# All tools errors")
            with gr.Row():
                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():
                sel_tool = gr.Dropdown(
                    label="Select a tool", choices=INC_TOOLS, value=INC_TOOLS[0]
                )

            with gr.Row():
                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_by_market(
                    error_df=error_by_markets, tool=tool
                )

            sel_tool.change(
                update_tool_error_plot, inputs=sel_tool, outputs=tool_error_plot
            )
            with gr.Row():
                sel_tool
            with gr.Row():
                tool_error_plot

            with gr.Row():
                gr.Markdown("# Tools distribution of errors per week")

            with gr.Row():
                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(
                    label="Select a week", choices=choices, value=choices[-1]
                )

            with gr.Row():
                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_by_market(
                    error_df=error_by_markets, week=selected_week
                )

            sel_tool.change(
                update_tool_error_plot, inputs=sel_tool, outputs=tool_error_plot
            )
            sel_week.change(
                update_week_error_plot, inputs=sel_week, outputs=week_error_plot
            )

            with gr.Row():
                sel_tool
            with gr.Row():
                tool_error_plot
            with gr.Row():
                sel_week
            with gr.Row():
                week_error_plot

        with gr.TabItem("ℹ️ About"):
            with gr.Accordion("About Olas Predict"):
                gr.Markdown(about_olas_predict)

            with gr.Accordion("About this dashboard"):
                gr.Markdown(about_this_dashboard)

demo.queue(default_concurrency_limit=40).launch()