fourth commit

app.py

@@ -1,5 +1,10 @@
+import subprocess
+import logging
 import gradio as gr
 import pandas as pd
+from apscheduler.schedulers.background import BackgroundScheduler
+from apscheduler.triggers.cron import CronTrigger
+from pytz import utc
 from tabs.trades import (
     prepare_trades, 
     get_overall_trades, 
@@ -22,7 +27,34 @@ from tabs.error import (
     plot_week_error_data
 )
 
-tools_df = pd.read_csv("./data/tools.csv")
+
+def refresh_data():
+    # Run the pull_data.py script and wait for it to finish
+    try:
+        result = subprocess.run(["python", "./scripts/pull_data.py"], check=True)
+        logging.info("Script executed successfully: %s", result)
+    except subprocess.CalledProcessError as e:
+        logging.error("Failed to run script: %s", e)
+        return  # Stop execution if the script fails
+
+    # Reload dataframes
+    try:
+        global tools_df, trades_df, error_df, error_overall_df, winning_rate_df, winning_rate_overall_df, trades_count_df, trades_winning_rate_df
+        logging.info("Refreshing data...")
+        tools_df = pd.read_csv("./data/tools.csv", low_memory=False)
+        trades_df = pd.read_csv("./data/all_trades_profitability.csv")
+        trades_df = prepare_trades(trades_df)
+        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_overall_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)
+        logging.info("Data refreshed.")
+    except Exception as e:
+        logging.error("Failed to refresh data: %s", e)
+
+tools_df = pd.read_csv("./data/tools.csv", low_memory=False)
 trades_df = pd.read_csv("./data/all_trades_profitability.csv")
 trades_df = prepare_trades(trades_df)
 
@@ -267,4 +299,8 @@ with demo:
             with gr.Accordion("About the Benchmark"):
                 gr.Markdown("This app shows the actual performance of Olas Predict tools on the live market.")
 
+# Create the scheduler
+scheduler = BackgroundScheduler(timezone=utc)
+scheduler.add_job(refresh_data, CronTrigger(hour=0, minute=0))  # Runs daily at 12 AM UTC
+scheduler.start()
 demo.queue(default_concurrency_limit=40).launch()

requirements.txt

@@ -4,4 +4,6 @@ huggingface-hub
 pyarrow
 web3
 requests
-gradio
+gradio
+apscheduler
+pytz

scripts/markets.py

@@ -27,7 +27,7 @@ import requests
 from tqdm import tqdm
 
 from typing import List, Dict
-
+from pathlib import Path
 
 ResponseItemType = List[Dict[str, str]]
 SubgraphResponseType = Dict[str, ResponseItemType]
@@ -47,7 +47,9 @@ OUTCOMES_FIELD = "outcomes"
 TITLE_FIELD = "title"
 MAX_UINT_HEX = "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
 DEFAULT_FILENAME = "fpmms.csv"
-
+SCRIPTS_DIR = Path(__file__).parent
+ROOT_DIR = SCRIPTS_DIR.parent
+DATA_DIR = ROOT_DIR / "data"
 FPMMS_QUERY = Template(
     """
     {
@@ -216,7 +218,7 @@ def etl(filename: Optional[str] = None) -> pd.DataFrame:
     fpmms = transform_fpmms(fpmms)
 
     if filename:
-        fpmms.to_csv(filename, index=False)
+        fpmms.to_csv(DATA_DIR / filename, index=False)
 
     return fpmms
 

scripts/profitability.py

@@ -27,7 +27,7 @@ from string import Template
 from enum import Enum
 from tqdm import tqdm
 import numpy as np
-
+from pathlib import Path
 
 IRRELEVANT_TOOLS = [
     "openai-text-davinci-002",
@@ -55,7 +55,9 @@ DEFAULT_TO_TIMESTAMP = 2147483647
 WXDAI_CONTRACT_ADDRESS = "0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d"
 DEFAULT_MECH_FEE = 0.01
 DUST_THRESHOLD = 10000000000000
-
+SCRIPTS_DIR = Path(__file__).parent
+ROOT_DIR = SCRIPTS_DIR.parent
+DATA_DIR = ROOT_DIR / "data"
 
 class MarketState(Enum):
     """Market state"""
@@ -383,7 +385,7 @@ def create_fpmmTrades(rpc: str):
     df.rename(columns={"creator": "trader_address"}, inplace=True)
 
     # save to csv
-    df.to_csv("fpmmTrades.csv", index=False)
+    df.to_csv(DATA_DIR / "fpmmTrades.csv", index=False)
 
     return df
 
@@ -418,8 +420,8 @@ def prepare_profitalibity_data(rpc: str):
     except FileNotFoundError:
         print("fpmmTrades.csv not found. Creating fpmmTrades.csv...")
         fpmmTrades = create_fpmmTrades(rpc)
-        fpmmTrades.to_csv("fpmmTrades.csv", index=False)
-        fpmmTrades = pd.read_csv("fpmmTrades.csv")
+        fpmmTrades.to_csv(DATA_DIR / "fpmmTrades.csv", index=False)
+        fpmmTrades = pd.read_csv(DATA_DIR / "fpmmTrades.csv")
 
     # make sure trader_address is in the columns
     assert "trader_address" in fpmmTrades.columns, "trader_address column not found"
@@ -618,8 +620,8 @@ def run_profitability_analysis(rpc):
     summary_df = summary_analyse(all_trades_df)
 
     # save to csv
-    all_trades_df.to_csv("all_trades_profitability.csv", index=False)
-    summary_df.to_csv("summary_profitability.csv", index=False)
+    all_trades_df.to_csv(DATA_DIR / "all_trades_profitability.csv", index=False)
+    summary_df.to_csv(DATA_DIR / "summary_profitability.csv", index=False)
 
     print("Done!")
 

scripts/{weekly_analysis.py → pull_data.py}

@@ -7,6 +7,7 @@ from tqdm import tqdm
 from web3 import Web3
 from typing import Optional
 import pandas as pd
+from pathlib import Path
 from functools import partial
 from markets import (
     etl as mkt_etl,
@@ -21,6 +22,9 @@ from profitability import run_profitability_analysis
 
 logging.basicConfig(level=logging.INFO)
 
+SCRIPTS_DIR = Path(__file__).parent
+ROOT_DIR = SCRIPTS_DIR.parent
+DATA_DIR = ROOT_DIR / "data"
 
 def get_question(text: str) -> str:
     """Get the question from a text."""
@@ -109,7 +113,7 @@ def weekly_analysis():
     tools['request_month_year_week'] = pd.to_datetime(tools['request_time']).dt.to_period('W').astype(str)
 
     # Save the tools
-    tools.to_csv(TOOLS_FILENAME, index=False)
+    tools.to_csv(DATA_DIR / TOOLS_FILENAME, index=False)
 
     logging.info("Weekly analysis files generated and saved")
 

scripts/tools.py

@@ -56,6 +56,8 @@ from web3 import Web3, HTTPProvider
 from web3.exceptions import MismatchedABI
 from web3.types import BlockParams
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
 
 CONTRACTS_PATH = "contracts"
 MECH_TO_INFO = {
@@ -111,7 +113,9 @@ IRRELEVANT_TOOLS = [
 SNAPSHOT_RATE = 10
 NUM_WORKERS = 10
 GET_CONTENTS_BATCH_SIZE = 1000
-
+SCRIPTS_DIR = Path(__file__).parent
+ROOT_DIR = SCRIPTS_DIR.parent
+DATA_DIR = ROOT_DIR / "data"
 
 class MechEventName(Enum):
     """The mech's event names."""
@@ -621,13 +625,13 @@ def store_progress(
             if "result" in content.columns:
                 content.drop(columns=["result"], inplace=True)
 
-            content.to_csv(event_filename, index=False, escapechar="\\")
+            content.to_csv(DATA_DIR / event_filename, index=False, escapechar="\\")
 
         # drop result and error columns
         if "result" in tools.columns:
             tools.drop(columns=["result"], inplace=True)
 
-        tools.to_csv(filename, index=False, escapechar="\\")
+        tools.to_csv(DATA_DIR / filename, index=False, escapechar="\\")
 
 
 def etl(

tabs/error.py

@@ -1,33 +1,38 @@
 import pandas as pd
 import gradio as gr
+from typing import List
 
 
 HEIGHT=600
 WIDTH=1000
 
-def set_error(row):
+def set_error(row: pd.Series) -> bool:
+    """Sets the error for the given 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)]
+def get_error_data(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)].copy()
     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):
+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 = 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):
+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(
         value=error_all_df,
         x="request_month_year_week",
@@ -43,8 +48,9 @@ def plot_error_data(error_all_df):
         width=WIDTH
     )
 
-def plot_tool_error_data(error_df, tool):
-    error_tool = error_df[error_df['tool'] == tool]
+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].copy()
     error_tool.columns = error_tool.columns.astype(str)
     error_tool['error_perc'] = error_tool['error_perc'].apply(lambda x: round(x, 4))
                 
@@ -63,8 +69,9 @@ def plot_tool_error_data(error_df, tool):
             width=WIDTH
     )
 
-def plot_week_error_data(error_df, week):
-    error_week = error_df[error_df['request_month_year_week'] == week]
+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].copy()
     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(
@@ -80,5 +87,4 @@ def plot_week_error_data(error_df, week):
         tooltip=["tool", "error_perc"],
         height=HEIGHT,
         width=WIDTH
-    )
-
+    )

tabs/tool_win.py

@@ -1,12 +1,14 @@
 import pandas as pd
 import gradio as gr
+from typing import List
 
 
 HEIGHT=600
 WIDTH=1000
 
 
-def set_error(row):
+def set_error(row: pd.Series) -> bool:
+    """Sets the error for the given row."""
     if row.error not in [True, False]:
         if not row.prompt_response:
             return True
@@ -14,7 +16,8 @@ def set_error(row):
     return row.error
 
 
-def get_tool_winning_rate(tools_df, inc_tools):
+def get_tool_winning_rate(tools_df: pd.DataFrame, inc_tools: List[str]) -> pd.DataFrame:
+    """Gets the tool winning rate data for the given tools and calculates the winning percentage."""
     tools_inc = tools_df[tools_df['tool'].isin(inc_tools)].copy()
     tools_inc['error'] = tools_inc.apply(set_error, axis=1)
     tools_non_error = tools_inc[tools_inc['error'] != True]
@@ -33,7 +36,8 @@ def get_tool_winning_rate(tools_df, inc_tools):
     return wins
 
 
-def get_overall_winning_rate(wins_df):
+def get_overall_winning_rate(wins_df: pd.DataFrame) -> pd.DataFrame:
+    """Gets the overall winning rate data for the given tools and calculates the winning percentage."""
     overall_wins = wins_df.groupby('request_month_year_week').agg({
         "0": 'sum',
         "1": 'sum',
@@ -43,10 +47,8 @@ def get_overall_winning_rate(wins_df):
     return overall_wins
 
 
-def plot_tool_winnings_overall(
-    wins_df,
-    winning_selector="win_perc"
-    ):
+def plot_tool_winnings_overall(wins_df: pd.DataFrame, winning_selector: str = "win_perc") -> gr.BarPlot:
+    """Plots the overall winning rate data for the given tools and calculates the winning percentage."""
     return gr.BarPlot(
         title="Winning Rate", 
         x_title="Date", 
@@ -63,7 +65,8 @@ def plot_tool_winnings_overall(
     )
 
 
-def plot_tool_winnings_by_tool(wins_df, tool):
+def plot_tool_winnings_by_tool(wins_df: pd.DataFrame, tool: str) -> gr.BarPlot:
+    """Plots the winning rate data for the given tool."""
     return gr.BarPlot(
                 title="Winning Rate", 
                 x_title="Week", 
@@ -77,4 +80,4 @@ def plot_tool_winnings_by_tool(wins_df, tool):
                 tooltip=["request_month_year_week", "win_perc"],
                 height=HEIGHT,
                 width=WIDTH
-            )
+            )

tabs/trades.py

@@ -5,21 +5,25 @@ import pandas as pd
 HEIGHT=600
 WIDTH=1000
 
-def prepare_trades(trades_df):
+def prepare_trades(trades_df: pd.DataFrame) -> pd.DataFrame:
+    """Prepares the trades data for analysis."""
     trades_df['creation_timestamp'] = pd.to_datetime(trades_df['creation_timestamp'])
+    trades_df['creation_timestamp'] = trades_df['creation_timestamp'].dt.tz_convert('UTC')
     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):
+def get_overall_trades(trades_df: pd.DataFrame) -> pd.DataFrame:
+    """Gets the overall trades data for the given tools and calculates the winning percentage."""
     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):
+def get_overall_winning_trades(trades_df: pd.DataFrame) -> pd.DataFrame:
+    """Gets the overall winning trades data for the given tools and calculates the winning percentage."""
     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()
@@ -27,7 +31,8 @@ def get_overall_winning_trades(trades_df):
     winning_trades.columns = ['month_year_week', 'winning_trade']
     return winning_trades
 
-def plot_trade_details(trade_detail, trades_df):
+def plot_trade_details(trade_detail: str, trades_df: pd.DataFrame) -> gr.LinePlot:
+    """Plots the trade details for the given trade detail."""
     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"]
@@ -164,7 +169,8 @@ def plot_trade_details(trade_detail, trades_df):
             width=WIDTH
         )    
     
-def plot_trades_by_week(trades_df):
+def plot_trades_by_week(trades_df: pd.DataFrame) -> gr.BarPlot:
+    """Plots the trades data for the given tools and calculates the winning percentage."""
     return gr.BarPlot(
         value=trades_df,
         x="month_year_week",
@@ -177,7 +183,8 @@ def plot_trades_by_week(trades_df):
         width=WIDTH
     )
 
-def plot_winning_trades_by_week(trades_df):
+def plot_winning_trades_by_week(trades_df: pd.DataFrame) -> gr.BarPlot:
+    """Plots the winning trades data for the given tools and calculates the winning percentage."""
     return gr.BarPlot(
         value=trades_df,
         x="month_year_week",
@@ -188,4 +195,4 @@ def plot_winning_trades_by_week(trades_df):
         tooltip=["month_year_week", "winning_trade"],
         height=HEIGHT,
         width=WIDTH
-    )
+    )