updating some graphs

app.py

@@ -3,6 +3,7 @@ import gradio as gr
 import pandas as pd
 import duckdb
 import logging
+import plotly.express as px
 
 from tabs.tokens_dist import (
     get_extreme_cases,
@@ -14,6 +15,7 @@ from tabs.dist_gap import (
     get_kde_with_trades,
     get_kde_with_total_bet_amount,
     get_dist_gap_time_evolution,
+    get_dist_gap_timeline_plotly,
 )
 
 
@@ -59,6 +61,8 @@ def prepare_data():
 
 demo = gr.Blocks()
 markets_data = prepare_data()
+print(f"markets data")
+markets_data["sample_date"] = pd.to_datetime(markets_data["sample_datetime"]).dt.date
 live_markets_data = markets_data.loc[markets_data["open"] == True]
 # filter only those with trades
 markets_data = markets_data.loc[markets_data["total_trades"] > 0]
@@ -77,7 +81,7 @@ with demo:
                     f"Market id = {best_market_id} Dist gap = {round(best_gap,2)}"
                 )
             with gr.Row():
-                best_case = get_dist_gap_time_evolution(
+                best_case = get_dist_gap_timeline_plotly(
                     best_market_id, live_markets_data
                 )
 
@@ -89,7 +93,7 @@ with demo:
                 )
 
             with gr.Row():
-                worst_case = get_dist_gap_time_evolution(
+                worst_case = get_dist_gap_timeline_plotly(
                     worst_market_id, live_markets_data
                 )
             with gr.Row():

requirements.txt

@@ -1,11 +1,12 @@
-pandas
+pandas==2.2.2
 seaborn
 matplotlib
 huggingface-hub 
 pyarrow
 requests
 gradio
-plotly
+plotly==5.24.0
+pydantic==2.8.2
 nbformat
 pytz
 duckdb

scripts/live_traders_data.py

@@ -14,16 +14,13 @@ from utils import SUBGRAPH_API_KEY, _to_content
 from queries import omen_market_trades_query
 
 
-
 headers = {
     "Accept": "application/json, multipart/mixed",
     "Content-Type": "application/json",
 }
 
 
-def _query_omen_xdai_subgraph(
-    fpmm_id: str, logger
-) -> dict[str, Any]:
+def _query_omen_xdai_subgraph(fpmm_id: str, logger) -> dict[str, Any]:
     """Query the subgraph."""
     omen_subgraph = OMEN_SUBGRAPH_URL.substitute(subgraph_api_key=SUBGRAPH_API_KEY)
     logger.info(f"omen_subgraph = {omen_subgraph}")
@@ -37,7 +34,7 @@ def _query_omen_xdai_subgraph(
             id_gt=id_gt,
             fpmm_id=fpmm_id,
         )
-        #logger.debug(f"query for the omen to collect trades {query}")
+        # logger.debug(f"query for the omen to collect trades {query}")
         content_json = _to_content(query)
 
         res = requests.post(omen_subgraph, headers=headers, json=content_json)
@@ -90,7 +87,6 @@ def transform_trades(trades_json: dict, logger) -> pd.DataFrame:
     return df
 
 
-
 def compute_votes_distribution(market_trades: pd.DataFrame, logger):
     """Function to compute the distribution of votes for the trades of a market"""
     logger.info("Computing the votes distribution")
@@ -102,15 +98,23 @@ def compute_votes_distribution(market_trades: pd.DataFrame, logger):
     percentage_index_1 = round((sum_outcome_index_1 / total_trades) * 100, 2)
     return (100 - percentage_index_1), percentage_index_1
 
-def compute_bought_tokens_distribution(trades_outcome_0: pd.DataFrame, trades_outcome_1: pd.DataFrame) -> Tuple:
-    """Function to compute the distribution of bought tokens from the trades on each outcome """
+
+def compute_bought_tokens_distribution(
+    trades_outcome_0: pd.DataFrame, trades_outcome_1: pd.DataFrame
+) -> Tuple:
+    """Function to compute the distribution of bought tokens from the trades on each outcome"""
     total_tokens_outcome_0 = sum(trades_outcome_0.outcomeTokensTraded)
     total_tokens_outcome_1 = sum(trades_outcome_1.outcomeTokensTraded)
     total_bought_tokens = total_tokens_outcome_0 + total_tokens_outcome_1
-    percentage_bought_outcome_0 = round((total_tokens_outcome_0/total_bought_tokens)*100, 2)
-    return percentage_bought_outcome_0, 100 - percentage_bought_outcome_0 
+    percentage_bought_outcome_0 = round(
+        (total_tokens_outcome_0 / total_bought_tokens) * 100, 2
+    )
+    return percentage_bought_outcome_0, 100 - percentage_bought_outcome_0
+
 
-def compute_price_weighted_perc(trades_outcome_0: pd.DataFrame, trades_outcome_1: pd.DataFrame, logger) -> Tuple:
+def compute_price_weighted_perc(
+    trades_outcome_0: pd.DataFrame, trades_outcome_1: pd.DataFrame, logger
+) -> Tuple:
     """It computes the price weighted distribution with the percentages of each outcome"""
     logger.info("Computing the price weighted distribution")
     total_usd_outcome_0 = sum(trades_outcome_0.collateralAmountUSD)
@@ -119,47 +123,54 @@ def compute_price_weighted_perc(trades_outcome_0: pd.DataFrame, trades_outcome_1
     if total_usd == 0.0:
         raise ValueError("The total amount of dollars is 0")
 
-    percentage_pwc_outcome_0 = round((total_usd_outcome_0/total_usd)*100, 2)
+    percentage_pwc_outcome_0 = round((total_usd_outcome_0 / total_usd) * 100, 2)
     logger.debug(f"total amount for outcome 0 = {total_usd_outcome_0}")
     logger.debug(f"total usd = {total_usd}")
-    return percentage_pwc_outcome_0, 100 - percentage_pwc_outcome_0 
+    return percentage_pwc_outcome_0, 100 - percentage_pwc_outcome_0
+
 
 def add_trading_info(fpmms: pd.DataFrame, current_timestamp: int, logger) -> None:
     """Function to update only the information related with the current timestamp"""
-    
+
     logger.info("Adding price weighted distribution per market")
     fpmms["liquidityMeasure"] = fpmms["liquidityMeasure"].apply(lambda x: int(x))
     # Iterate over the markets
     for i, fpmm in tqdm(fpmms.iterrows(), total=len(fpmms), desc="Analysing trades"):
         # update the trades for this market and at this specific current_timestamp
-        logger.debug(f"current timestamp = {current_timestamp} and market timestamp={fpmm["sample_timestamp"]}")
+        # logger.debug(f"current timestamp = {current_timestamp} and market timestamp={fpmm["sample_timestamp"]}")
         to_update = fpmm["open"] and fpmm["sample_timestamp"] == current_timestamp
         if not to_update:  # jump closed markets or old data
             logger.debug("Jumping this row")
             continue
         market_id = fpmm["id"]
-        
+
         logger.info(f"Adding trades information for the market {market_id}")
-        market_trades_json = _query_omen_xdai_subgraph(
-            fpmm_id=market_id, logger=logger
-        )
+        market_trades_json = _query_omen_xdai_subgraph(fpmm_id=market_id, logger=logger)
         market_trades = transform_trades(market_trades_json, logger)
-        fpmms.at[i,"total_trades"] = len(market_trades)
+        fpmms.at[i, "total_trades"] = len(market_trades)
 
         if len(market_trades) > 0:
             # adding average trade size
-            market_trades["collateralAmountUSD"] = market_trades.collateralAmountUSD.apply(lambda x: round(float(x),3))
-            market_trades["outcomeTokensTraded"] = market_trades.outcomeTokensTraded.apply(lambda x: int(x))
+            market_trades["collateralAmountUSD"] = (
+                market_trades.collateralAmountUSD.apply(lambda x: round(float(x), 3))
+            )
+            market_trades["outcomeTokensTraded"] = (
+                market_trades.outcomeTokensTraded.apply(lambda x: int(x))
+            )
             mean_trade_size = market_trades.collateralAmountUSD.mean()
             total_bet_amount = sum(market_trades.collateralAmountUSD)
             # trades for outcome 0
-            trades_outcome_0 = market_trades.loc[market_trades["outcomeIndex"]==0]
+            trades_outcome_0 = market_trades.loc[market_trades["outcomeIndex"] == 0]
             logger.debug(f"Total trades for outcome 0 = {len(trades_outcome_0)}")
             # trades for outcome 1
-            trades_outcome_1 = market_trades.loc[market_trades["outcomeIndex"]==1]
+            trades_outcome_1 = market_trades.loc[market_trades["outcomeIndex"] == 1]
             logger.debug(f"Total trades for outcome 1 = {len(trades_outcome_1)}")
-            first_outcome, second_outcome = compute_price_weighted_perc(trades_outcome_0, trades_outcome_1, logger)
-            bought_tokens_first, bought_tokens_second = compute_bought_tokens_distribution(trades_outcome_0, trades_outcome_1)
+            first_outcome, second_outcome = compute_price_weighted_perc(
+                trades_outcome_0, trades_outcome_1, logger
+            )
+            bought_tokens_first, bought_tokens_second = (
+                compute_bought_tokens_distribution(trades_outcome_0, trades_outcome_1)
+            )
             metric = abs(fpmm["first_token_perc"] - first_outcome)
             logger.info(f"metric for this market {metric}")
         else:
@@ -168,16 +179,16 @@ def add_trading_info(fpmms: pd.DataFrame, current_timestamp: int, logger) -> Non
             bought_tokens_first = bought_tokens_second = 0.0
             first_outcome = second_outcome = 0.0
             metric = 0.0
-        fpmms.at[i,"mean_trade_size"] = mean_trade_size
-        fpmms.at[i,"total_bet_amount"] = total_bet_amount
+        fpmms.at[i, "mean_trade_size"] = mean_trade_size
+        fpmms.at[i, "total_bet_amount"] = total_bet_amount
         logger.info(
             f"first outcome pwc ={first_outcome}, second outcome pwc = {second_outcome}"
         )
-        fpmms.at[i,"price_weighted_first_outcome_perc"] = first_outcome
-        fpmms.at[i,"price_weighted_second_outcome_perc"] = second_outcome
-        fpmms.at[i,"bought_tokens_first_perc"] = bought_tokens_first
-        fpmms.at[i,"bought_tokens_second_perc"] = bought_tokens_second
-        fpmms.at[i,"dist_gap_perc"] = metric
+        fpmms.at[i, "price_weighted_first_outcome_perc"] = first_outcome
+        fpmms.at[i, "price_weighted_second_outcome_perc"] = second_outcome
+        fpmms.at[i, "bought_tokens_first_perc"] = bought_tokens_first
+        fpmms.at[i, "bought_tokens_second_perc"] = bought_tokens_second
+        fpmms.at[i, "dist_gap_perc"] = metric
     logger.debug("Dataset after adding trading info")
     logger.debug(fpmms.head())
     return

tabs/dist_gap.py

@@ -9,16 +9,18 @@ HEIGHT = 300
 WIDTH = 600
 
 
-def get_dist_gap_time_evolution(market_id: str, all_markets: pd.DataFrame):
+def get_dist_gap_time_evolution(
+    market_id: str, all_markets: pd.DataFrame
+) -> gr.LinePlot:
     """Function to paint the evolution in time of the distance gap between the tokens and the price weighted distributions"""
     sns.set_style("darkgrid")
     selected_market = all_markets.loc[all_markets["id"] == market_id]
-    selected_market["sample_datetime"] = selected_market["sample_datetime"].astype(str)
+    selected_market["sample_date"] = selected_market["sample_date"].astype(str)
     selected_market.columns = selected_market.columns.astype(str)
 
     return gr.LinePlot(
         value=selected_market,
-        x="sample_datetime",
+        x="sample_date",
         y="dist_gap_perc",
         y_title="Distribution gap in %",
         interactive=True,
@@ -34,31 +36,35 @@ def get_dist_gap_time_evolution(market_id: str, all_markets: pd.DataFrame):
     )
 
 
-def get_avg_gap_time_evolution(all_markets: pd.DataFrame):
-    avg_dist_gap_perc = (
-        all_markets.groupby("sample_datetime")["dist_gap_perc"].mean().reset_index()
+def get_dist_gap_timeline_plotly(market_id: str, all_markets: pd.DataFrame) -> gr.Plot:
+    selected_market = all_markets.loc[all_markets["id"] == market_id]
+    fig = px.line(selected_market, x="sample_date", y="dist_gap_perc")
+    fig.update_layout(
+        xaxis_title="Day of the sample",
+        yaxis_title="Distribution gap in %",
     )
-    avg_dist_gap_perc["sample_datetime"] = avg_dist_gap_perc["sample_datetime"].astype(
-        str
+    fig.update_layout(width=WIDTH, height=HEIGHT)
+    fig.update_xaxes(tickformat="%b-%d-%Y")
+    return gr.Plot(value=fig)
+
+
+def get_avg_gap_time_evolution(all_markets: pd.DataFrame) -> gr.Plot:
+    avg_dist_gap_perc = (
+        all_markets.groupby("sample_date")["dist_gap_perc"].mean().reset_index()
     )
+    avg_dist_gap_perc["sample_date"] = avg_dist_gap_perc["sample_date"].astype(str)
     avg_dist_gap_perc.rename(
         columns={"dist_gap_perc": "mean_dist_gap_perc"}, inplace=True
     )
-    avg_dist_gap_perc.columns = avg_dist_gap_perc.columns.astype(str)
-    return gr.LinePlot(
-        value=avg_dist_gap_perc,
-        x="sample_datetime",
-        y="mean_dist_gap_perc",
-        y_title="Mean dist gap percentage (%)",
-        interactive=True,
-        show_actions_button=True,
-        tooltip=[
-            "sample_datetime",
-            "mean_dist_gap_perc",
-        ],
-        height=HEIGHT,
-        width=WIDTH,
+    fig = px.line(avg_dist_gap_perc, x="sample_date", y="mean_dist_gap_perc")
+    fig.update_layout(
+        xaxis_title="Day of the sample",
+        yaxis_title="Mean dist gap percentage (%)",
     )
+    # fig.update_layout(width=WIDTH, height=HEIGHT)
+    # fig.update_xaxes(tickangle=45)
+    fig.update_xaxes(tickformat="%b-%d-%Y")
+    return gr.Plot(value=fig)
 
 
 def get_top_best_behaviour_markets(markets_data: pd.DataFrame):