# -*- coding: utf-8 -*- # ------------------------------------------------------------------------------ # # Copyright 2023 Valory AG # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # ------------------------------------------------------------------------------ import functools import warnings from datetime import datetime, timedelta from dotenv import load_dotenv from typing import Optional, Generator, Callable import pandas as pd import requests from tqdm import tqdm from typing import List, Dict from utils import SUBGRAPH_API_KEY, ROOT_DIR, TMP_DIR, transform_to_datetime from web3_utils import ( FPMM_QS_CREATOR, FPMM_PEARL_CREATOR, query_omen_xdai_subgraph, OMEN_SUBGRAPH_URL, ) from queries import ( FPMMS_QUERY, ID_FIELD, DATA_FIELD, ANSWER_FIELD, QUERY_FIELD, TITLE_FIELD, OUTCOMES_FIELD, ERROR_FIELD, QUESTION_FIELD, FPMMS_FIELD, ) ResponseItemType = List[Dict[str, str]] SubgraphResponseType = Dict[str, ResponseItemType] BATCH_SIZE = 1000 DEFAULT_TO_TIMESTAMP = 2147483647 # around year 2038 DEFAULT_FROM_TIMESTAMP = 0 MAX_UINT_HEX = "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" DEFAULT_FILENAME = "fpmms.parquet" market_creators_map = {"quickstart": FPMM_QS_CREATOR, "pearl": FPMM_PEARL_CREATOR} class RetriesExceeded(Exception): """Exception to raise when retries are exceeded during data-fetching.""" def __init__( self, msg="Maximum retries were exceeded while trying to fetch the data!" ): super().__init__(msg) def hacky_retry(func: Callable, n_retries: int = 3) -> Callable: """Create a hacky retry strategy. Unfortunately, we cannot use `requests.packages.urllib3.util.retry.Retry`, because the subgraph does not return the appropriate status codes in case of failure. Instead, it always returns code 200. Thus, we raise exceptions manually inside `make_request`, catch those exceptions in the hacky retry decorator and try again. Finally, if the allowed number of retries is exceeded, we raise a custom `RetriesExceeded` exception. :param func: the input request function. :param n_retries: the maximum allowed number of retries. :return: The request method with the hacky retry strategy applied. """ @functools.wraps(func) def wrapper_hacky_retry(*args, **kwargs) -> SubgraphResponseType: """The wrapper for the hacky retry. :return: a response dictionary. """ retried = 0 while retried <= n_retries: try: if retried > 0: warnings.warn(f"Retrying {retried}/{n_retries}...") return func(*args, **kwargs) except (ValueError, ConnectionError) as e: warnings.warn(e.args[0]) finally: retried += 1 raise RetriesExceeded() return wrapper_hacky_retry @hacky_retry def query_subgraph(url: str, query: str, key: str) -> SubgraphResponseType: """Query a subgraph. Args: url: the subgraph's URL. query: the query to be used. key: the key to use in order to access the required data. Returns: a response dictionary. """ content = {QUERY_FIELD: query} headers = { "Accept": "application/json", "Content-Type": "application/json", } res = requests.post(url, json=content, headers=headers) if res.status_code != 200: raise ConnectionError( "Something went wrong while trying to communicate with the subgraph " f"(Error: {res.status_code})!\n{res.text}" ) body = res.json() if ERROR_FIELD in body.keys(): raise ValueError(f"The given query is not correct: {body[ERROR_FIELD]}") data = body.get(DATA_FIELD, {}).get(key, None) if data is None: raise ValueError(f"Unknown error encountered!\nRaw response: \n{body}") return data def transform_fpmmTrades(df: pd.DataFrame) -> pd.DataFrame: print("Transforming trades dataframe") # convert creator to address df["creator"] = df["creator"].apply(lambda x: x["id"]) # normalize fpmm column fpmm = pd.json_normalize(df["fpmm"]) fpmm.columns = [f"fpmm.{col}" for col in fpmm.columns] df = pd.concat([df, fpmm], axis=1) # drop fpmm column df.drop(["fpmm"], axis=1, inplace=True) # change creator to creator_address df.rename(columns={"creator": "trader_address"}, inplace=True) return df def create_fpmmTrades( from_timestamp: int = DEFAULT_FROM_TIMESTAMP, to_timestamp: int = DEFAULT_TO_TIMESTAMP, ): """Create fpmmTrades for all trades.""" print("Getting trades from Quickstart markets") # Quickstart trades qs_trades_json = query_omen_xdai_subgraph( trader_category="quickstart", from_timestamp=from_timestamp, to_timestamp=to_timestamp, fpmm_from_timestamp=from_timestamp, fpmm_to_timestamp=to_timestamp, ) # convert to dataframe qs_df = pd.DataFrame(qs_trades_json["data"]["fpmmTrades"]) qs_df["market_creator"] = "quickstart" qs_df = transform_fpmmTrades(qs_df) print(f"length of the qs_trades dataset {len(qs_df)}") # Pearl trades print("Getting trades from Pearl markets") pearl_trades_json = query_omen_xdai_subgraph( trader_category="pearl", from_timestamp=from_timestamp, to_timestamp=DEFAULT_TO_TIMESTAMP, fpmm_from_timestamp=from_timestamp, fpmm_to_timestamp=DEFAULT_TO_TIMESTAMP, ) # convert to dataframe pearl_df = pd.DataFrame(pearl_trades_json["data"]["fpmmTrades"]) pearl_df["market_creator"] = "pearl" pearl_df = transform_fpmmTrades(pearl_df) print(f"length of the pearl_trades dataset {len(pearl_df)}") return pd.concat([qs_df, pearl_df], ignore_index=True) def fpmms_fetcher(trader_category: str) -> Generator[ResponseItemType, int, None]: """An indefinite fetcher for the FPMMs.""" omen_subgraph = OMEN_SUBGRAPH_URL.substitute(subgraph_api_key=SUBGRAPH_API_KEY) print(f"omen_subgraph = {omen_subgraph}") if trader_category == "pearl": creator_id = FPMM_PEARL_CREATOR else: # quickstart creator_id = FPMM_QS_CREATOR while True: fpmm_id = yield fpmms_query = FPMMS_QUERY.substitute( creator=creator_id, fpmm_id=fpmm_id, fpmms_field=FPMMS_FIELD, first=BATCH_SIZE, id_field=ID_FIELD, answer_field=ANSWER_FIELD, question_field=QUESTION_FIELD, outcomes_field=OUTCOMES_FIELD, title_field=TITLE_FIELD, ) print(f"markets query = {fpmms_query}") yield query_subgraph(omen_subgraph, fpmms_query, FPMMS_FIELD) def fetch_qs_fpmms() -> pd.DataFrame: """Fetch all the fpmms of the creator.""" latest_id = "" fpmms = [] trader_category = "quickstart" print(f"Getting markets for {trader_category}") fetcher = fpmms_fetcher(trader_category) for _ in tqdm(fetcher, unit="fpmms", unit_scale=BATCH_SIZE): batch = fetcher.send(latest_id) if len(batch) == 0: break latest_id = batch[-1].get(ID_FIELD, "") if latest_id == "": raise ValueError(f"Unexpected data format retrieved: {batch}") fpmms.extend(batch) return pd.DataFrame(fpmms) def fetch_pearl_fpmms() -> pd.DataFrame: """Fetch all the fpmms of the creator.""" latest_id = "" fpmms = [] trader_category = "pearl" print(f"Getting markets for {trader_category}") fetcher = fpmms_fetcher(trader_category) for _ in tqdm(fetcher, unit="fpmms", unit_scale=BATCH_SIZE): batch = fetcher.send(latest_id) if len(batch) == 0: break latest_id = batch[-1].get(ID_FIELD, "") if latest_id == "": raise ValueError(f"Unexpected data format retrieved: {batch}") fpmms.extend(batch) return pd.DataFrame(fpmms) def get_answer(fpmm: pd.Series) -> str: """Get an answer from its index, using Series of an FPMM.""" return fpmm[QUESTION_FIELD][OUTCOMES_FIELD][fpmm[ANSWER_FIELD]] def transform_fpmms(fpmms: pd.DataFrame) -> pd.DataFrame: """Transform an FPMMS dataframe.""" transformed = fpmms.dropna() transformed = transformed.drop_duplicates([ID_FIELD]) transformed = transformed.loc[transformed[ANSWER_FIELD] != MAX_UINT_HEX] transformed.loc[:, ANSWER_FIELD] = ( transformed[ANSWER_FIELD].str.slice(-1).astype(int) ) transformed.loc[:, ANSWER_FIELD] = transformed.apply(get_answer, axis=1) transformed = transformed.drop(columns=[QUESTION_FIELD]) return transformed def etl(filename: Optional[str] = None) -> pd.DataFrame: """Fetch, process, store and return the markets as a Dataframe.""" qs_fpmms = fetch_qs_fpmms() qs_fpmms = transform_fpmms(qs_fpmms) qs_fpmms["market_creator"] = "quickstart" print(f"Results for the market creator quickstart. Len = {len(qs_fpmms)}") pearl_fpmms = fetch_pearl_fpmms() pearl_fpmms = transform_fpmms(pearl_fpmms) pearl_fpmms["market_creator"] = "pearl" print(f"Results for the market creator pearl. Len = {len(pearl_fpmms)}") fpmms = pd.concat([qs_fpmms, pearl_fpmms], ignore_index=True) if filename: fpmms.to_parquet(ROOT_DIR / filename, index=False) return fpmms def read_global_trades_file() -> pd.DataFrame: try: trades_filename = "fpmmTrades.parquet" fpmms_trades = pd.read_parquet(TMP_DIR / trades_filename) except FileNotFoundError: print("Error: fpmmTrades.parquet not found. No market creator added") return return fpmms_trades def add_market_creator(tools: pd.DataFrame) -> None: # Check if fpmmTrades.parquet is in the same directory fpmms_trades = read_global_trades_file() tools["market_creator"] = "" # traverse the list of traders tools_no_market_creator = 0 traders_list = list(tools.trader_address.unique()) for trader_address in traders_list: market_creator = "" try: trades = fpmms_trades[fpmms_trades["trader_address"] == trader_address] market_creator = trades.iloc[0]["market_creator"] # first value is enough except Exception: print(f"ERROR getting the market creator of {trader_address}") tools_no_market_creator += 1 continue # update tools.loc[tools["trader_address"] == trader_address, "market_creator"] = ( market_creator ) # filter those tools where we don't have market creator info tools = tools.loc[tools["market_creator"] != ""] print(f"Number of tools with no market creator info = {tools_no_market_creator}") return tools def fpmmTrades_etl( trades_filename: str, from_timestamp: int, to_timestamp: int = DEFAULT_TO_TIMESTAMP ) -> None: print("Generating the trades file") try: fpmmTrades = create_fpmmTrades( from_timestamp=from_timestamp, to_timestamp=to_timestamp ) except FileNotFoundError: print(f"Error creating {trades_filename} file .") # make sure trader_address is in the columns assert "trader_address" in fpmmTrades.columns, "trader_address column not found" # lowercase and strip creator_address fpmmTrades["trader_address"] = fpmmTrades["trader_address"].str.lower().str.strip() fpmmTrades.to_parquet(ROOT_DIR / trades_filename, index=False) return fpmmTrades def check_current_week_data(trades_df: pd.DataFrame) -> pd.DataFrame: """Function to check if all current weeks data is present, if not, then add the missing data from previous file""" # Get current date now = datetime.now() # Get start of the current week (Monday) start_of_week = now - timedelta(days=now.weekday()) start_of_week = start_of_week.replace(hour=0, minute=0, second=0, microsecond=0) print(f"start of the week = {start_of_week}") trades_df["creation_timestamp"] = pd.to_datetime(trades_df["creationTimestamp"]) trades_df["creation_date"] = trades_df["creation_timestamp"].dt.date trades_df["creation_date"] = pd.to_datetime(trades_df["creation_date"]) # Check dataframe min_date = min(trades_df.creation_date) if min_date > start_of_week: # missing data of current week in the trades file fpmms_trades = read_global_trades_file() # get missing data missing_data = fpmms_trades[ (fpmms_trades["creation_date"] >= start_of_week) & (fpmms_trades["creation_date"] < min_date) ] merge_df = pd.concat([trades_df, missing_data], ignore_index=True) merge_df.drop_duplicates("id", keep="last", inplace=True) return merge_df # no update needed return trades_df def update_fpmmTrades_parquet(trades_filename: str) -> pd.DataFrame: # Read old trades parquet file try: old_trades_df = pd.read_parquet(TMP_DIR / "fpmmTrades.parquet") except Exception as e: print(f"Error reading old trades parquet file {e}") return None try: new_trades_df = pd.read_parquet(ROOT_DIR / trades_filename) except Exception as e: print(f"Error reading new trades parquet file {e}") return None # lowercase and strip creator_address new_trades_df["trader_address"] = ( new_trades_df["trader_address"].str.lower().str.strip() ) # ensure creationTimestamp compatibility try: new_trades_df["creationTimestamp"] = new_trades_df["creationTimestamp"].apply( lambda x: transform_to_datetime(x) ) except Exception as e: print(f"Transformation not needed") try: old_trades_df["creationTimestamp"] = old_trades_df["creationTimestamp"].apply( lambda x: transform_to_datetime(x) ) except Exception as e: print(f"Transformation not needed") # merge two dataframes merge_df = pd.concat([old_trades_df, new_trades_df], ignore_index=True) # avoid numpy objects merge_df["fpmm.arbitrationOccurred"] = merge_df["fpmm.arbitrationOccurred"].astype( bool ) merge_df["fpmm.isPendingArbitration"] = merge_df[ "fpmm.isPendingArbitration" ].astype(bool) # Check for duplicates print(f"Initial length before removing duplicates in fpmmTrades= {len(merge_df)}") # Remove duplicates # fpmm.outcomes is a numpy array merge_df.drop_duplicates("id", keep="last", inplace=True) print(f"Final length after removing duplicates in fpmmTrades= {len(merge_df)}") # save the parquet file merge_df.to_parquet(TMP_DIR / "fpmmTrades.parquet", index=False) return def update_fpmmTrades(from_date: str): from_timestamp = pd.Timestamp(datetime.strptime(from_date, "%Y-%m-%d")).tz_localize( "UTC" ) fpmmTrades_etl( trades_filename="new_fpmmTrades.parquet", from_timestamp=int(from_timestamp.timestamp()), ) update_fpmmTrades_parquet("new_fpmmTrades.parquet") if __name__ == "__main__": cutoff_date = "2025-01-20" load_dotenv() update_fpmmTrades(cutoff_date)