First graph with market creator types

.gitignore

@@ -0,0 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+.DS_Store
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

README.md

@@ -1,8 +1,8 @@
 ---
 title: Trader Agents Performance
-emoji: 👁
-colorFrom: pink
-colorTo: red
+emoji: 🏃
+colorFrom: gray
+colorTo: yellow
 sdk: gradio
 sdk_version: 4.44.0
 app_file: app.py

app.py

@@ -0,0 +1,172 @@
+from datetime import datetime, timedelta
+import gradio as gr
+import pandas as pd
+import duckdb
+import logging
+
+
+from scripts.metrics import (
+    compute_weekly_metrics_by_market_creator,
+    compute_weekly_metrics_by_trader_type,
+)
+from tabs.trader_plots import (
+    plot_trader_metrics_by_market_creator,
+    plot_trader_metrics_by_trader_type,
+    default_trader_metric,
+    trader_metric_choices,
+    get_trader_metrics_text,
+)
+
+
+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_all_data():
+    """
+    Get parquet file from weekly stats
+    """
+    logger.info("Getting traders data")
+    con = duckdb.connect(":memory:")
+    # Query to fetch data from all_trades_profitability.parquet
+    query1 = f"""
+    SELECT *
+    FROM read_parquet('./data/all_trades_profitability.parquet')
+    """
+    df1 = con.execute(query1).fetchdf()
+    logger.info("Got all data from all_trades_profitability.parquet")
+
+    con.close()
+
+    return df1
+
+
+def prepare_data():
+
+    all_trades = get_all_data()
+
+    all_trades["creation_date"] = all_trades["creation_timestamp"].dt.date
+
+    # adding multi-bet variables
+    volume_trades_per_trader_and_market = (
+        all_trades.groupby(["trader_address", "title"])["roi"].count().reset_index()
+    )
+    volume_trades_per_trader_and_market.rename(
+        columns={"roi": "nr_trades_per_market"}, inplace=True
+    )
+
+    trader_agents_data = pd.merge(
+        all_trades, volume_trades_per_trader_and_market, on=["trader_address", "title"]
+    )
+    # right now all traders are of the same type: singlebet
+    trader_agents_data["trader_type"] = "singlebet"
+
+    trader_agents_data = trader_agents_data.sort_values(
+        by="creation_timestamp", ascending=True
+    )
+
+    trader_agents_data["month_year_week"] = (
+        trader_agents_data["creation_timestamp"].dt.to_period("W").dt.strftime("%b-%d")
+    )
+    return trader_agents_data
+
+
+trader_agents_data = prepare_data()
+print("trader agents data before computing metrics")
+print(trader_agents_data.head())
+demo = gr.Blocks()
+# get weekly metrics by market creator: qs, pearl or all.
+weekly_metrics_by_market_creator = compute_weekly_metrics_by_market_creator(
+    trader_agents_data
+)
+print("weekly metrics by market creator")
+print(weekly_metrics_by_market_creator.head())
+# get weekly metrics by trader type: multibet, singlebet or all.
+# weekly_metrics_by_market_strategy = compute_weekly_metrics_by_trader_type(
+#     trader_agents_data
+# )
+with demo:
+    gr.HTML("<h1>Trader agents monitoring dashboard </h1>")
+    gr.Markdown(
+        "This app shows the weekly performance of the trader agents in Olas Predict."
+    )
+
+    with gr.Tabs():
+        with gr.TabItem("🔥Trader Agents Dashboard"):
+            # TODO Implement metrics showing market creator
+            with gr.Row():
+                gr.Markdown("# Weekly metrics of trader agents by market creator")
+            with gr.Row():
+                trader_details_selector = gr.Dropdown(
+                    label="Select a trader metric",
+                    choices=trader_metric_choices,
+                    value=default_trader_metric,
+                )
+
+            with gr.Row():
+                with gr.Column(scale=3):
+                    trader_markets_plot = plot_trader_metrics_by_market_creator(
+                        metric_name=default_trader_metric,
+                        traders_df=weekly_metrics_by_market_creator,
+                    )
+                with gr.Column(scale=1):
+                    trade_details_text = get_trader_metrics_text()
+
+            def update_trader_details(trader_detail):
+                return plot_trader_metrics_by_market_creator(
+                    metric_name=trader_detail,
+                    traders_df=weekly_metrics_by_market_creator,
+                )
+
+            trader_details_selector.change(
+                update_trader_details,
+                inputs=trader_details_selector,
+                outputs=trader_markets_plot,
+            )
+
+            # with gr.Row():
+            #     gr.Markdown(
+            #         "# Weekly metrics for trader agents by trader type (multibet or singlebet)"
+            #     )
+            # with gr.Row():
+            #     trade_details_selector = gr.Dropdown(
+            #         label="Select a trader metric",
+            #         choices=trader_metric_choices,
+            #         value=default_trader_metric,
+            #     )
+
+            # with gr.Row():
+            #     with gr.Column(scale=3):
+            #         trader_type_plot = plot_trader_metrics_by_trader_type(
+            #             metric_name=default_trader_metric,
+            #             trades_df=trades_df,
+            #         )
+            #     with gr.Column(scale=1):
+            #         trade_details_text = get_trader_metrics_text()
+
+            # def update_trader_details(trader_detail):
+            #     return plot_trader_metrics_by_trader_type(
+            #         metric_name=trader_detail,
+            #         trades_df=trades_df,
+            #     )
+
+            # trader_details_selector.change(
+            #     update_trader_details,
+            #     inputs=trade_details_selector,
+            #     outputs=trader_details_plot,
+            # )
+
+demo.queue(default_concurrency_limit=40).launch()

data/all_trades_profitability.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a12ff001752f6ca93c5ebbbf1ba39aa2c9a194d798cd4136c10bb096b8eb5490
+size 698837

data/markets_live_data.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:69a3fffac1b1e11e818cdf3c709fd3006d6f93107df947693548a05bc66f337d
+size 145777

scripts/metrics.py

@@ -0,0 +1,171 @@
+import pandas as pd
+from tqdm import tqdm
+
+DEFAULT_MECH_FEE = 0.01  # xDAI
+
+
+def compute_metrics(trader_address: str, trader_data: pd.DataFrame) -> dict:
+
+    if len(trader_data) == 0:
+        print("No data to compute metrics")
+        return {}
+
+    weekly_metrics = {}
+    weekly_metrics["trader_address"] = trader_address
+    total_net_earnings = trader_data.net_earnings.sum()
+    total_bet_amounts = trader_data.collateral_amount.sum()
+    total_num_mech_calls = trader_data.num_mech_calls.sum()
+    weekly_metrics["net_earnings"] = total_net_earnings
+    weekly_metrics["earnings"] = trader_data.earnings.sum()
+    weekly_metrics["bet_amount"] = total_bet_amounts
+    weekly_metrics["nr_mech_calls"] = total_num_mech_calls
+    total_fee_amounts = trader_data.mech_fee_amount.sum()
+    total_costs = (
+        total_bet_amounts
+        + total_fee_amounts
+        + (total_num_mech_calls * DEFAULT_MECH_FEE)
+    )
+    weekly_metrics["roi"] = total_net_earnings / total_costs
+    return weekly_metrics
+
+
+def compute_trader_metrics_by_trader_type(
+    trader_address: str, week_traders_data: pd.DataFrame, trader_type: str = "all"
+) -> pd.DataFrame:
+    """This function computes for a specific week the different metrics: roi, net_earnings, earnings, bet_amount, nr_mech_calls.
+    The global roi of the trader agent by computing the individual net profit and the indivicual costs values
+    achieved per market and dividing both.
+    It is possible to filter by trader type: multibet, singlebet, all"""
+    assert "trader_type" in week_traders_data.columns
+    filtered_traders_data = week_traders_data.loc[
+        week_traders_data["trader_address"] == trader_address
+    ]
+
+    if trader_type != "all":  # compute only for the specific type
+        filtered_traders_data = filtered_traders_data.loc[
+            filtered_traders_data["trader_type"] == trader_type
+        ]
+        if len(filtered_traders_data) == 0:
+            return pd.DataFrame()  # No Data
+
+    return compute_metrics(trader_address, filtered_traders_data)
+
+
+def compute_trader_metrics_by_market_creator(
+    trader_address: str, week_traders_data: pd.DataFrame, market_creator: str = "all"
+) -> dict:
+    """This function computes for a specific week the different metrics: roi, net_earnings, earnings, bet_amount, nr_mech_calls.
+    The global roi of the trader agent by computing the individual net profit and the indivicual costs values
+    achieved per market and dividing both.
+    It is possible to filter by market creator: quickstart, pearl, all"""
+    assert "market_creator" in week_traders_data.columns
+    filtered_traders_data = week_traders_data.loc[
+        week_traders_data["trader_address"] == trader_address
+    ]
+    if market_creator != "all":  # compute only for the specific market creator
+        filtered_traders_data = filtered_traders_data.loc[
+            filtered_traders_data["market_creator"] == market_creator
+        ]
+        if len(filtered_traders_data) == 0:
+            tqdm.write(f"No data. Skipping market creator {market_creator}")
+            return {}  # No Data
+    tqdm.write(
+        f"Volume of data for trader {trader_address} and market creator {market_creator} = {len(filtered_traders_data)}"
+    )
+    metrics = compute_metrics(trader_address, filtered_traders_data)
+    return metrics
+
+
+def merge_trader_metrics(
+    trader: str, weekly_data: pd.DataFrame, week: str
+) -> pd.DataFrame:
+    trader_metrics = []
+    # computation as specification 1 for all types of markets
+    weekly_metrics_all = compute_trader_metrics_by_market_creator(
+        trader, weekly_data, market_creator="all"
+    )
+    weekly_metrics_all["month_year_week"] = week
+    weekly_metrics_all["market_creator"] = "all"
+    trader_metrics.append(weekly_metrics_all)
+
+    # computation as specification 1 for quickstart markets
+    weekly_metrics_qs = compute_trader_metrics_by_market_creator(
+        trader, weekly_data, market_creator="quickstart"
+    )
+    if len(weekly_metrics_qs) > 0:
+        weekly_metrics_qs["month_year_week"] = week
+        weekly_metrics_qs["market_creator"] = "quickstart"
+        trader_metrics.append(weekly_metrics_qs)
+    # computation as specification 1 for pearl markets
+    weekly_metrics_pearl = compute_trader_metrics_by_market_creator(
+        trader, weekly_data, market_creator="pearl"
+    )
+    if len(weekly_metrics_pearl) > 0:
+        weekly_metrics_pearl["month_year_week"] = week
+        weekly_metrics_pearl["market_creator"] = "pearl"
+        trader_metrics.append(weekly_metrics_pearl)
+    result = pd.DataFrame.from_dict(trader_metrics, orient="columns")
+    tqdm.write(f"Total length of all trader metrics for this week = {len(result)}")
+    return result
+
+
+def compute_weekly_metrics_by_market_creator(
+    trader_agents_data: pd.DataFrame,
+) -> pd.DataFrame:
+    """Function to compute the metrics at the trader level per week and with different categories by market creator"""
+    contents = []
+    all_weeks = list(trader_agents_data.month_year_week.unique())
+    for week in all_weeks:
+        weekly_data = trader_agents_data.loc[
+            trader_agents_data["month_year_week"] == week
+        ]
+        print(f"Computing weekly metrics for week ={week} by market creator")
+        # traverse each trader agent
+        traders = list(weekly_data.trader_address.unique())
+        for trader in tqdm(traders, desc=f"Trader' metrics", unit="metrics"):
+            contents.append(merge_trader_metrics(trader, weekly_data, week))
+    print("End computing all weekly metrics by market creator")
+    return pd.concat(contents, ignore_index=True)
+
+
+def compute_weekly_metrics_by_trader_type(
+    trader_agents_data: pd.DataFrame,
+) -> pd.DataFrame:
+    """Function to compute the metrics at the trader level per week and with different types of traders"""
+    contents = []
+    all_weeks = list(trader_agents_data.month_year_week.unique())
+    for week in all_weeks:
+        weekly_data = trader_agents_data.loc[
+            trader_agents_data["month_year_week"] == week
+        ]
+        print(f"Computing weekly metrics for week ={week} by trader type")
+        # traverse each trader agent
+        traders = list(weekly_data.trader_address.unique())
+        for trader in tqdm(traders, desc=f"Trader' metrics", unit="metrics"):
+            # computation as specification 1 for all types of traders
+            weekly_metrics = compute_trader_metrics_by_trader_type(
+                trader, weekly_data, trader_type="all"
+            )
+            weekly_metrics["month_year_week"] = week
+            weekly_metrics["trader_type"] = "all"
+            contents.append(weekly_metrics)
+
+            # computation as specification 1 for multibet traders
+            weekly_metrics = compute_trader_metrics_by_trader_type(
+                trader, weekly_data, trader_type="multibet"
+            )
+            if len(weekly_metrics) > 0:
+                weekly_metrics["month_year_week"] = week
+                weekly_metrics["trader_type"] = "multibet"
+                contents.append(weekly_metrics)
+
+            # computation as specification 1 for singlebet traders
+            weekly_metrics = compute_trader_metrics_by_trader_type(
+                trader, weekly_data, trader_type="singlebet"
+            )
+            if len(weekly_metrics) > 0:
+                weekly_metrics["month_year_week"] = week
+                weekly_metrics["trader_type"] = "singlebet"
+                contents.append(weekly_metrics)
+    print("End computing all weekly metrics by trader types")
+    return pd.concat(contents, ignore_index=True)

tabs/trader_plots.py

@@ -0,0 +1,75 @@
+import gradio as gr
+import pandas as pd
+import plotly.express as px
+
+trader_metric_choices = [
+    "mech calls",
+    "bet amount",
+    "earnings",
+    "net earnings",
+    "ROI",
+]
+default_trader_metric = "ROI"
+
+
+def get_trader_metrics_text() -> gr.Markdown:
+    metric_text = """ 
+        ## Description of the graph
+        These metrics are computed weekly. The statistical measures are:
+        * min, max, 25th(q1), 50th(median) and 75th(q2) percentiles
+        * the upper and lower fences to delimit possible outliers
+        * the average values as the dotted lines
+        """
+
+    return gr.Markdown(metric_text)
+
+
+def plot_trader_metrics_by_market_creator(
+    metric_name: str, traders_df: pd.DataFrame
+) -> gr.Plot:
+    """Plots the weekly trader metrics."""
+
+    if metric_name == "mech calls":
+        metric_name = "mech_calls"
+        column_name = "nr_mech_calls"
+        yaxis_title = "Total nr of mech calls per trader"
+    elif metric_name == "ROI":
+        column_name = "roi"
+        yaxis_title = "Total ROI (net profit/cost)"
+    elif metric_name == "bet amount":
+        metric_name = "bet_amount"
+        column_name = metric_name
+        yaxis_title = "Total bet amount per trader (xDAI)"
+    elif metric_name == "net earnings":
+        metric_name = "net_earnings"
+        column_name = metric_name
+        yaxis_title = "Total net profit per trader (xDAI)"
+    else:  # earnings
+        column_name = metric_name
+        yaxis_title = "Total gross profit per trader (xDAI)"
+
+    traders_filtered = traders_df[["month_year_week", "market_creator", column_name]]
+
+    fig = px.box(
+        traders_filtered,
+        x="month_year_week",
+        y=column_name,
+        color="market_creator",
+        color_discrete_sequence=["purple", "goldenrod", "darkgreen"],
+        category_orders={"market_creator": ["pearl", "quickstart", "all"]},
+    )
+    fig.update_traces(boxmean=True)
+    fig.update_layout(
+        xaxis_title="Week",
+        yaxis_title=yaxis_title,
+        legend=dict(yanchor="top", y=0.5),
+    )
+    fig.update_xaxes(tickformat="%b %d\n%Y")
+
+    return gr.Plot(
+        value=fig,
+    )
+
+
+def plot_trader_metrics_by_trader_type():
+    print("WIP")