updating weekly roi for pearl agents computation

scripts/{daa.py → predict_kpis.py}

@@ -2,18 +2,25 @@ import pandas as pd
 from datetime import datetime, timedelta, UTC
 from web3_utils import ROOT_DIR
 from utils import measure_execution_time
-from get_mech_info import fetch_block_number, get_last_block_number
+from get_mech_info import (
+    fetch_block_number,
+    get_last_block_number,
+    read_all_trades_profitability,
+)
 from tqdm import tqdm
 import requests
 import os
 import pickle
+from utils import TMP_DIR, INC_TOOLS, ROOT_DIR
 from concurrent.futures import ThreadPoolExecutor
 from gnosis_timestamps import get_all_txs_between_blocks_from_trader_address
 from dune_client.types import QueryParameter
 from dune_client.client import DuneClient
 from dune_client.query import QueryBase
 from staking import add_predict_agent_category
-from functools import wraps
+from typing import Tuple
+from tools_metrics import prepare_tools
+from profitability import DEFAULT_MECH_FEE
 
 DATETIME_60_DAYS_AGO = datetime.now(UTC) - timedelta(days=60)
 
@@ -254,8 +261,148 @@ def prepare_daa_data():
     df.to_parquet(ROOT_DIR / "pearl_agents.parquet", index=False, compression="gzip")
 
 
+def get_mech_requests_on_closed_markets_by_pearl_agents(
+    trades_closed_markets: pd.DataFrame,
+) -> pd.DataFrame:
+    # read the list of pearl agents
+    pearl_agents = pd.read_parquet(ROOT_DIR / "pearl_agents.parquet")
+    unique_addresses = pearl_agents["safe_address"].unique()
+
+    # prepare a list of closed markets from trades_closed_markets
+    closed_markets = trades_closed_markets.title.unique()
+
+    # filter the mech requests done by agents on closed markets
+    try:
+        tools_df = pd.read_parquet(TMP_DIR / "tools.parquet")
+        tools_df = prepare_tools(tools_df)
+    except Exception as e:
+        print(f"Error reading tools parquet file {e}")
+        return None
+    agents_activity = tools_df[tools_df["trader_address"].isin(unique_addresses)].copy()
+    agents_activity = agents_activity[agents_activity["title"].isin(closed_markets)]
+    if len(agents_activity) > 0:
+        return agents_activity
+    raise ValueError("No agents activity found on closed markets")
+
+
+def get_trades_on_closed_markets_by_pearl_agents() -> pd.DataFrame:
+    # read the list of pearl agents
+    pearl_agents = pd.read_parquet(ROOT_DIR / "pearl_agents.parquet")
+    unique_addresses = pearl_agents["safe_address"].unique()
+
+    # read the trades datasource on closed markets
+    all_trades_on_closed_markets = read_all_trades_profitability()
+
+    # filter the trades done by pearl agents
+    agent_trades_df = all_trades_on_closed_markets[
+        all_trades_on_closed_markets["trader_address"].isin(unique_addresses)
+    ].copy()
+    if len(agent_trades_df) > 0:
+        return agent_trades_df
+    raise ValueError("No trades found for the pearl agents")
+
+
+def compute_market_agent_roi(
+    agent_trades: pd.DataFrame,
+    mech_calls: pd.DataFrame,
+    agent: str,
+    week: datetime,
+) -> dict:
+    # ROI formula net_earnings/total_costs
+    earnings = agent_trades.earnings.sum()
+    total_market_fees = agent_trades.trade_fee_amount.sum()
+    total_mech_fees = len(mech_calls) * DEFAULT_MECH_FEE
+    total_bet_amount = agent_trades.collateral_amount.sum()
+    total_costs = total_bet_amount + total_market_fees + total_mech_fees
+    net_earnings = earnings - total_costs
+    if total_costs == 0:
+        raise ValueError(f"Total costs for agent {agent} in week {week} are zero")
+    roi = net_earnings / total_costs
+    return {
+        "trader_address": agent,
+        "week_start": week,
+        "roi": roi,
+        "net_earnings": net_earnings,
+        "total_bet_amount": total_bet_amount,
+        "total_mech_calls": len(mech_calls),
+    }
+
+
+def compute_weekly_avg_roi_pearl_agents() -> pd.DataFrame:
+    agent_trades = get_trades_on_closed_markets_by_pearl_agents()
+    agent_mech_requests = get_mech_requests_on_closed_markets_by_pearl_agents(
+        agent_trades
+    )
+
+    agent_trades["creation_timestamp"] = pd.to_datetime(
+        agent_trades["creation_timestamp"]
+    )
+    agent_trades["creation_timestamp"] = agent_trades[
+        "creation_timestamp"
+    ].dt.tz_convert("UTC")
+    agent_trades["creation_date"] = agent_trades["creation_timestamp"].dt.date
+    agent_trades = agent_trades.sort_values(by="creation_timestamp", ascending=True)
+
+    agent_trades["week_start"] = (
+        agent_trades["creation_timestamp"].dt.to_period("W").dt.start_time
+    )
+
+    grouped_trades = agent_trades.groupby("week_start")
+    contents = []
+
+    # Iterate through the groups (each group represents a week)
+    for week, week_data in grouped_trades:
+        print(f"Week: {week}")  # Print the week identifier
+
+        # for all closed markets
+        closed_markets = week_data.title.unique()
+        agents = week_data.trader_address.unique()
+        for agent in agents:
+            # compute all trades done by the agent on those markets, no matter from which week
+            agent_markets_data = agent_trades.loc[
+                (agent_trades["trader_address"] == agent)
+                & (agent_trades["title"].isin(closed_markets))
+            ]
+            if len(agent_markets_data) == 0:
+                # not betting activity
+                continue
+            # filter mech requests done by the agent on that market
+            agent_mech_calls = agent_mech_requests.loc[
+                (agent_mech_requests["trader_address"] == agent)
+                & (agent_mech_requests["title"].isin(closed_markets))
+            ]
+            # compute the ROI for that market, that trader and that week
+            try:
+                # Convert the dictionary to DataFrame before appending
+                roi_dict = compute_market_agent_roi(
+                    agent_markets_data, agent_mech_calls, agent, week
+                )
+                contents.append(pd.DataFrame([roi_dict]))
+            except ValueError as e:
+                print(f"Skipping ROI calculation: {e}")
+                continue
+
+    weekly_agents_data = pd.concat(contents, ignore_index=True)
+    # average the ROI for all samples (at the trader/market level) in that week
+    weekly_avg_roi_data = (
+        weekly_agents_data.groupby("week_start")["roi"]
+        .mean()
+        .reset_index(name="avg_weekly_roi")
+    )
+    return weekly_avg_roi_data
+
+
+def compute_daily_avg_roi_pearl_agents() -> pd.DataFrame:
+    # TODO Implementation
+    print("WIP")
+
+
 if __name__ == "__main__":
     prepare_daa_data()
-    # prepare_predict_services_dataset()
+    prepare_predict_services_dataset()
     # dune = setup_dune_python_client()
     # load_predict_services_file(dune_client=dune)
+    # final_dataset = compute_weekly_avg_roi_pearl_agents()
+    # print(final_dataset.head())
+    # # save in a file
+    # final_dataset.to_parquet(ROOT_DIR / "weekly_avg_roi_pearl_agents.parquet")

scripts/pull_data.py

@@ -136,7 +136,7 @@ def only_new_weekly_analysis():
 
     save_historical_data()
     try:
-        clean_old_data_from_parquet_files("2025-04-08")
+        clean_old_data_from_parquet_files("2025-04-11")
         clean_old_data_from_json_files()
     except Exception as e:
         print("Error cleaning the oldest information from parquet files")

scripts/tools_metrics.py

@@ -1,5 +1,4 @@
 import pandas as pd
-from typing import List
 from utils import TMP_DIR, INC_TOOLS, ROOT_DIR