new pearl markets and new graphs

app.py

@@ -8,9 +8,13 @@ import logging
 from tabs.trades import (
     prepare_trades,
     get_overall_trades,
+    get_overall_by_market_trades,
     get_overall_winning_trades,
+    get_overall_winning_by_market_trades,
     plot_trades_by_week,
+    plot_trades_per_market_by_week,
     plot_winning_trades_by_week,
+    plot_winning_trades_per_market_by_week,
     plot_trade_details,
 )
 from tabs.tool_win import (
@@ -138,6 +142,7 @@ def prepare_data():
     Prepare the data for the dashboard
     """
     tools_df, trades_df, tools_accuracy_info, invalid_trades = get_all_data()
+    print(trades_df.info())
 
     tools_df["request_time"] = pd.to_datetime(tools_df["request_time"])
     trades_df["creation_timestamp"] = pd.to_datetime(trades_df["creation_timestamp"])
@@ -220,7 +225,20 @@ with demo:
                 trade_details_selector
             with gr.Row():
                 trade_details_plot
-
+        with gr.TabItem("🔥Trades per market Dashboard"):
+            with gr.Row():
+                gr.Markdown("# Number of trades split by market type per week")
+            with gr.Row():
+                trades_by_week_plot = plot_trades_per_market_by_week(
+                    trades_df=get_overall_by_market_trades(trades_df=trades_df)
+                )
+            with gr.Row():
+                gr.Markdown("# Percentage of winning trades per week")
+            with gr.Row():
+                winning_trades_by_week_plot = plot_winning_trades_per_market_by_week(
+                    trades_df=get_overall_winning_by_market_trades(trades_df=trades_df)
+                )
+            # TODO add average ROI value per market
         with gr.TabItem("🚀 Tool Winning Dashboard"):
             with gr.Row():
                 gr.Markdown("# All tools winning performance")

data/all_trades_profitability.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f077d410e0e9118e024c64ec5a1b6c33cfbe2864a0cda91050c9a08b1443608a
-size 1481357
+oid sha256:2228c601aaa9c6f33d8a018b946bbd654e392a27b4d1b2b7310ea8d4019bf640
+size 1651423

data/fpmmTrades.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6ed74c013906f4b8af747c09f3a55fe8f8978d6c707a12f6ec21431c33e662fc
-size 4831023
+oid sha256:56d7bc7c2dd1970b3f3d97d70a9d4e92134b17da9469bcfbd2ecdcf85e6b7aea
+size 5345188

data/fpmms.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:de1475b066a0c1f953043529f0f6ffd740341cbc0dac219b46342fb6d78cf18b
-size 389209
+oid sha256:d9df2136521afbf13e5d3675f14eead02ae66b2fce1c5e9e09fdd10d057f7dec
+size 411157

data/invalid_trades.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9fcaad515535cdfee4cb3a853d61a77ce9f6ea9345120ef6717570c376a6af48
-size 251293
+oid sha256:efdca1d658e69a2d61ead2e38513a66cfa37beb64ccd4d642493dd77f02c4ba8
+size 247018

data/summary_profitability.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:000194cbb06cf7c42e4f54083a69e1d9dbbcc7f5a216b30a0756e0f66019c34e
-size 29506
+oid sha256:e6fb720990290b9df24681e10aca6d545a4bab615f166bf4861be14d2465cdd3
+size 34952

requirements.txt

@@ -1,10 +1,10 @@
-pandas==2.0.1
+pandas==2.2.2
 seaborn
 matplotlib
 huggingface-hub 
 pyarrow
 requests
-gradio==4.13.0
+gradio==4.27.0
 plotly
 nbformat
 pytz

scripts/markets.py

@@ -47,8 +47,9 @@ SubgraphResponseType = Dict[str, ResponseItemType]
 
 
 CREATOR = "0x89c5cc945dd550BcFfb72Fe42BfF002429F46Fec"
+PEARL_CREATOR = "0xFfc8029154ECD55ABED15BD428bA596E7D23f557"
 BATCH_SIZE = 1000
-# OMEN_SUBGRAPH = "https://api.thegraph.com/subgraphs/name/protofire/omen-xdai"
+
 OMEN_SUBGRAPH_URL = Template(
     """https://gateway-arbitrum.network.thegraph.com/api/${subgraph_api_key}/subgraphs/id/9fUVQpFwzpdWS9bq5WkAnmKbNNcoBwatMR4yZq81pbbz"""
 )
@@ -142,14 +143,19 @@ def query_subgraph(url: str, query: str, key: str) -> SubgraphResponseType:
     return data
 
 
-def fpmms_fetcher() -> Generator[ResponseItemType, int, None]:
+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 = PEARL_CREATOR
+    else:  # quickstart
+        creator_id = CREATOR
     while True:
         fpmm_id = yield
         fpmms_query = FPMMS_QUERY.substitute(
-            creator=CREATOR,
+            creator=creator_id,
             fpmm_id=fpmm_id,
             fpmms_field=FPMMS_FIELD,
             first=BATCH_SIZE,
@@ -159,15 +165,38 @@ def fpmms_fetcher() -> Generator[ResponseItemType, int, None]:
             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_fpmms() -> pd.DataFrame:
+def fetch_qs_fpmms() -> pd.DataFrame:
     """Fetch all the fpmms of the creator."""
     latest_id = ""
     fpmms = []
-    fetcher = fpmms_fetcher()
+    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:
@@ -203,8 +232,16 @@ def transform_fpmms(fpmms: pd.DataFrame) -> pd.DataFrame:
 
 def etl(filename: Optional[str] = None) -> pd.DataFrame:
     """Fetch, process, store and return the markets as a Dataframe."""
-    fpmms = fetch_fpmms()
-    fpmms = transform_fpmms(fpmms)
+    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 quickstart. Len = {len(pearl_fpmms)}")
+    fpmms = pd.concat([qs_fpmms, pearl_fpmms], ignore_index=True)
 
     if filename:
         fpmms.to_parquet(DATA_DIR / filename, index=False)
@@ -213,4 +250,4 @@ def etl(filename: Optional[str] = None) -> pd.DataFrame:
 
 
 if __name__ == "__main__":
-    etl(DEFAULT_FILENAME)
+    etl("all_fpmms.parquet")

scripts/profitability.py

@@ -36,7 +36,8 @@ from queries import omen_xdai_trades_query, conditional_tokens_gc_user_query
 QUERY_BATCH_SIZE = 1000
 DUST_THRESHOLD = 10000000000000
 INVALID_ANSWER = -1
-FPMM_CREATOR = "0x89c5cc945dd550bcffb72fe42bff002429f46fec"
+FPMM_QS_CREATOR = "0x89c5cc945dd550bcffb72fe42bff002429f46fec"
+FPMM_PEARL_CREATOR = "0xFfc8029154ECD55ABED15BD428bA596E7D23f557"
 DEFAULT_FROM_DATE = "1970-01-01T00:00:00"
 DEFAULT_TO_DATE = "2038-01-19T03:14:07"
 DEFAULT_FROM_TIMESTAMP = 0
@@ -143,6 +144,7 @@ headers = {
 
 
 def _query_omen_xdai_subgraph(
+    trader_category: str,
     from_timestamp: float,
     to_timestamp: float,
     fpmm_from_timestamp: float,
@@ -156,10 +158,14 @@ def _query_omen_xdai_subgraph(
     print(f"omen_subgraph = {omen_subgraph}")
     grouped_results = defaultdict(list)
     id_gt = ""
+    if trader_category == "quickstart":
+        creator_id = FPMM_QS_CREATOR.lower()
+    else:  # pearl
+        creator_id = FPMM_PEARL_CREATOR.lower()
 
     while True:
         query = omen_xdai_trades_query.substitute(
-            fpmm_creator=FPMM_CREATOR.lower(),
+            fpmm_creator=creator_id,
             creationTimestamp_gte=int(from_timestamp),
             creationTimestamp_lte=int(to_timestamp),
             fpmm_creationTimestamp_gte=int(fpmm_from_timestamp),
@@ -251,22 +257,8 @@ def _is_redeemed(user_json: dict[str, Any], fpmmTrade: dict[str, Any]) -> bool:
     return False
 
 
-def create_fpmmTrades(rpc: str, from_timestamp: float = DEFAULT_FROM_TIMESTAMP):
-    """Create fpmmTrades for all trades."""
-    trades_json = _query_omen_xdai_subgraph(
-        from_timestamp=from_timestamp,
-        to_timestamp=DEFAULT_TO_TIMESTAMP,
-        fpmm_from_timestamp=from_timestamp,
-        fpmm_to_timestamp=DEFAULT_TO_TIMESTAMP,
-    )
-
-    print(f"length of the trades_json dataset {len(trades_json)}")
-
-    # convert to dataframe
-    df = pd.DataFrame(trades_json["data"]["fpmmTrades"])
-    print(df.head())
-    print(df.info())
-
+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"])
 
@@ -280,10 +272,48 @@ def create_fpmmTrades(rpc: str, from_timestamp: float = DEFAULT_FROM_TIMESTAMP):
 
     # change creator to creator_address
     df.rename(columns={"creator": "trader_address"}, inplace=True)
-
+    print(df.head())
+    print(df.info())
     return df
 
 
+def create_fpmmTrades(rpc: str, from_timestamp: float = DEFAULT_FROM_TIMESTAMP):
+    """Create fpmmTrades for all trades."""
+    # Quickstart trades
+    qs_trades_json = _query_omen_xdai_subgraph(
+        trader_category="quickstart",
+        from_timestamp=from_timestamp,
+        to_timestamp=DEFAULT_TO_TIMESTAMP,
+        fpmm_from_timestamp=from_timestamp,
+        fpmm_to_timestamp=DEFAULT_TO_TIMESTAMP,
+    )
+
+    print(f"length of the qs_trades_json dataset {len(qs_trades_json)}")
+
+    # convert to dataframe
+    qs_df = pd.DataFrame(qs_trades_json["data"]["fpmmTrades"])
+    qs_df["market_creator"] = "quickstart"
+    qs_df = transform_fpmmTrades(qs_df)
+
+    # Pearl trades
+    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,
+    )
+
+    print(f"length of the pearl_trades_json dataset {len(pearl_trades_json)}")
+
+    # convert to dataframe
+    pearl_df = pd.DataFrame(pearl_trades_json["data"]["fpmmTrades"])
+    pearl_df["market_creator"] = "pearl"
+    pearl_df = transform_fpmmTrades(pearl_df)
+
+    return pd.concat([qs_df, pearl_df], ignore_index=True)
+
+
 def prepare_profitalibity_data(
     rpc: str,
     tools_filename: str = "tools.parquet",
@@ -518,6 +548,7 @@ def run_profitability_analysis(
         rpc, tools_filename, trades_filename, from_timestamp
     )
     tools["trader_address"] = tools["trader_address"].str.lower()
+    print(f"List of market creators = {trades["trader_address"].unique()}")
 
     # all trades profitability df
     print("Analysing trades...")

tabs/trades.py

@@ -2,51 +2,96 @@ import gradio as gr
 import pandas as pd
 
 
-HEIGHT=600
-WIDTH=1000
+HEIGHT = 600
+WIDTH = 1000
+
 
 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)
+    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: 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 = 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_by_market_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(["market_creator", "month_year_week"]).size().reset_index()
+    )
     trades_count.columns = trades_count.columns.astype(str)
-    trades_count.rename(columns={'0': 'trades'}, inplace=True)
+    trades_count.rename(columns={"0": "trades"}, inplace=True)
     return trades_count
 
+
 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 = (
+        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()
+    winning_trades.columns = winning_trades.columns.astype(str)
+    winning_trades.columns = ["month_year_week", "winning_trade"]
+    return winning_trades
+
+
+def get_overall_winning_by_market_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(["market_creator", "month_year_week"])["winning_trade"].sum()
+        / trades_df.groupby(["market_creator", "month_year_week"])[
+            "winning_trade"
+        ].count()
+        * 100
+    )
     # winning_trades is a series, give it a dataframe
     winning_trades = winning_trades.reset_index()
     winning_trades.columns = winning_trades.columns.astype(str)
-    winning_trades.columns = ['month_year_week', 'winning_trade']
+    winning_trades.columns = ["market_creator", "month_year_week", "winning_trade"]
     return winning_trades
 
+
 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"]
-        trades_filtered = trades_filtered.groupby("month_year_week")["num_mech_calls"].quantile([0.25, 0.5, 0.75]).unstack()
+        trades_filtered = trades_df[trades_df["creation_timestamp"] > "2023-09-01"]
+        trades_filtered = (
+            trades_filtered.groupby("month_year_week")["num_mech_calls"]
+            .quantile([0.25, 0.5, 0.75])
+            .unstack()
+        )
         trades_filtered.columns = trades_filtered.columns.astype(str)
         trades_filtered.reset_index(inplace=True)
         trades_filtered.columns = [
             "month_year_week",
             "25th_percentile",
             "50th_percentile",
-            "75th_percentile"
+            "75th_percentile",
         ]
         # reformat the data as percentile, date, value
-        trades_filtered = trades_filtered.melt(id_vars=["month_year_week"], var_name="percentile", value_name="mech_calls")
+        trades_filtered = trades_filtered.melt(
+            id_vars=["month_year_week"], var_name="percentile", value_name="mech_calls"
+        )
 
         return gr.LinePlot(
             value=trades_filtered,
@@ -58,22 +103,30 @@ def plot_trade_details(trade_detail: str, trades_df: pd.DataFrame) -> gr.LinePlo
             show_actions_button=True,
             tooltip=["month_year_week", "percentile", "mech_calls"],
             height=HEIGHT,
-            width=WIDTH
+            width=WIDTH,
         )
-    
+
     if trade_detail == "collateral amount":
-        trades_filtered = trades_df[trades_df["creation_timestamp"] >"2023-09-01"]
-        trades_filtered = trades_filtered.groupby("month_year_week")["collateral_amount"].quantile([0.25, 0.5, 0.75]).unstack()
+        trades_filtered = trades_df[trades_df["creation_timestamp"] > "2023-09-01"]
+        trades_filtered = (
+            trades_filtered.groupby("month_year_week")["collateral_amount"]
+            .quantile([0.25, 0.5, 0.75])
+            .unstack()
+        )
         trades_filtered.columns = trades_filtered.columns.astype(str)
         trades_filtered.reset_index(inplace=True)
         trades_filtered.columns = [
             "month_year_week",
             "25th_percentile",
             "50th_percentile",
-            "75th_percentile"
+            "75th_percentile",
         ]
         # reformat the data as percentile, date, value
-        trades_filtered = trades_filtered.melt(id_vars=["month_year_week"], var_name="percentile", value_name="collateral_amount")
+        trades_filtered = trades_filtered.melt(
+            id_vars=["month_year_week"],
+            var_name="percentile",
+            value_name="collateral_amount",
+        )
 
         return gr.LinePlot(
             value=trades_filtered,
@@ -85,22 +138,28 @@ def plot_trade_details(trade_detail: str, trades_df: pd.DataFrame) -> gr.LinePlo
             show_actions_button=True,
             tooltip=["month_year_week", "percentile", "collateral_amount"],
             height=HEIGHT,
-            width=WIDTH
+            width=WIDTH,
         )
 
     if trade_detail == "earnings":
-        trades_filtered = trades_df[trades_df["creation_timestamp"] >"2023-09-01"]
-        trades_filtered = trades_filtered.groupby("month_year_week")["earnings"].quantile([0.25, 0.5, 0.75]).unstack()
+        trades_filtered = trades_df[trades_df["creation_timestamp"] > "2023-09-01"]
+        trades_filtered = (
+            trades_filtered.groupby("month_year_week")["earnings"]
+            .quantile([0.25, 0.5, 0.75])
+            .unstack()
+        )
         trades_filtered.columns = trades_filtered.columns.astype(str)
         trades_filtered.reset_index(inplace=True)
         trades_filtered.columns = [
             "month_year_week",
             "25th_percentile",
             "50th_percentile",
-            "75th_percentile"
+            "75th_percentile",
         ]
         # reformat the data as percentile, date, value
-        trades_filtered = trades_filtered.melt(id_vars=["month_year_week"], var_name="percentile", value_name="earnings")
+        trades_filtered = trades_filtered.melt(
+            id_vars=["month_year_week"], var_name="percentile", value_name="earnings"
+        )
 
         return gr.LinePlot(
             value=trades_filtered,
@@ -112,22 +171,30 @@ def plot_trade_details(trade_detail: str, trades_df: pd.DataFrame) -> gr.LinePlo
             show_actions_button=True,
             tooltip=["month_year_week", "percentile", "earnings"],
             height=HEIGHT,
-            width=WIDTH
+            width=WIDTH,
         )
-    
+
     if trade_detail == "net earnings":
-        trades_filtered = trades_df[trades_df["creation_timestamp"] >"2023-09-01"]
-        trades_filtered = trades_filtered.groupby("month_year_week")["net_earnings"].quantile([0.25, 0.5, 0.75]).unstack()
+        trades_filtered = trades_df[trades_df["creation_timestamp"] > "2023-09-01"]
+        trades_filtered = (
+            trades_filtered.groupby("month_year_week")["net_earnings"]
+            .quantile([0.25, 0.5, 0.75])
+            .unstack()
+        )
         trades_filtered.columns = trades_filtered.columns.astype(str)
         trades_filtered.reset_index(inplace=True)
         trades_filtered.columns = [
             "month_year_week",
             "25th_percentile",
             "50th_percentile",
-            "75th_percentile"
+            "75th_percentile",
         ]
         # reformat the data as percentile, date, value
-        trades_filtered = trades_filtered.melt(id_vars=["month_year_week"], var_name="percentile", value_name="net_earnings")
+        trades_filtered = trades_filtered.melt(
+            id_vars=["month_year_week"],
+            var_name="percentile",
+            value_name="net_earnings",
+        )
 
         return gr.LinePlot(
             value=trades_filtered,
@@ -139,22 +206,28 @@ def plot_trade_details(trade_detail: str, trades_df: pd.DataFrame) -> gr.LinePlo
             show_actions_button=True,
             tooltip=["month_year_week", "percentile", "net_earnings"],
             height=HEIGHT,
-            width=WIDTH
-        )        
-    
+            width=WIDTH,
+        )
+
     if trade_detail == "ROI":
-        trades_filtered = trades_df[trades_df["creation_timestamp"] >"2023-09-01"]
-        trades_filtered = trades_filtered.groupby("month_year_week")["roi"].quantile([0.25, 0.5, 0.75]).unstack()
+        trades_filtered = trades_df[trades_df["creation_timestamp"] > "2023-09-01"]
+        trades_filtered = (
+            trades_filtered.groupby("month_year_week")["roi"]
+            .quantile([0.25, 0.5, 0.75])
+            .unstack()
+        )
         trades_filtered.columns = trades_filtered.columns.astype(str)
         trades_filtered.reset_index(inplace=True)
         trades_filtered.columns = [
             "month_year_week",
             "25th_percentile",
             "50th_percentile",
-            "75th_percentile"
+            "75th_percentile",
         ]
         # reformat the data as percentile, date, value
-        trades_filtered = trades_filtered.melt(id_vars=["month_year_week"], var_name="percentile", value_name="ROI")
+        trades_filtered = trades_filtered.melt(
+            id_vars=["month_year_week"], var_name="percentile", value_name="ROI"
+        )
 
         return gr.LinePlot(
             value=trades_filtered,
@@ -166,9 +239,32 @@ def plot_trade_details(trade_detail: str, trades_df: pd.DataFrame) -> gr.LinePlo
             show_actions_button=True,
             tooltip=["month_year_week", "percentile", "ROI"],
             height=HEIGHT,
-            width=WIDTH
-        )    
-    
+            width=WIDTH,
+        )
+
+
+def plot_average_roi_per_market_by_week(trades_df: pd.DataFrame) -> gr.LinePlot:
+
+    mean_roi_per_market_by_week = (
+        trades_df.groupby(["market_creator", "month_year_week"])["roi"]
+        .mean()
+        .reset_index()
+    )
+    mean_roi_per_market_by_week.rename(columns={"roi": "mean_roi"}, inplace=True)
+    return gr.LinePlot(
+        value=mean_roi_per_market_by_week,
+        x="month_year_week",
+        y="ROI",
+        color="market_creator",
+        show_label=True,
+        interactive=True,
+        show_actions_button=True,
+        tooltip=["month_year_week", "market_creator", "mean_roi"],
+        height=HEIGHT,
+        width=WIDTH,
+    )
+
+
 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(
@@ -180,9 +276,27 @@ def plot_trades_by_week(trades_df: pd.DataFrame) -> gr.BarPlot:
         show_actions_button=True,
         tooltip=["month_year_week", "trades"],
         height=HEIGHT,
-        width=WIDTH
+        width=WIDTH,
+    )
+
+
+def plot_trades_per_market_by_week(trades_df: pd.DataFrame) -> gr.BarPlot:
+    """Plots the trades data for the given tools and calculates the winning percentage."""
+    assert "market_creator" in trades_df.columns
+    return gr.BarPlot(
+        value=trades_df,
+        x="month_year_week",
+        y="trades",
+        color="market_creator",
+        show_label=True,
+        interactive=True,
+        show_actions_button=True,
+        tooltip=["month_year_week", "trades"],
+        height=HEIGHT,
+        width=WIDTH,
     )
 
+
 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(
@@ -194,5 +308,22 @@ def plot_winning_trades_by_week(trades_df: pd.DataFrame) -> gr.BarPlot:
         show_actions_button=True,
         tooltip=["month_year_week", "winning_trade"],
         height=HEIGHT,
-        width=WIDTH
-    )
+        width=WIDTH,
+    )
+
+
+def plot_winning_trades_per_market_by_week(trades_df: pd.DataFrame) -> gr.BarPlot:
+    """Plots the winning trades data for the given tools and calculates the winning percentage."""
+    assert "market_creator" in trades_df.columns
+    return gr.BarPlot(
+        value=trades_df,
+        x="month_year_week",
+        y="winning_trade",
+        color="market_creator",
+        show_label=True,
+        interactive=True,
+        show_actions_button=True,
+        tooltip=["month_year_week", "winning_trade"],
+        height=HEIGHT,
+        width=WIDTH,
+    )