added new errors category

daily_mech_requests.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8d31ad9b43b30b4150ffd56ce7415f32b06948175a7741a84528193cc3c2f5a0
-size 10517
+oid sha256:b48a239b687487a1bcfb600f1c4a349f63bdb58cb0b713f82ce21b0fb15045eb
+size 10551

error_by_markets.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ee7141ac13bf0744360073500864040fe4dec86ac580d66542cf2b74b31f76e0
-size 11931
+oid sha256:ec71562860cca20e54e28dd84be086e25aa43d3bfb5909f9b427c15797777adc
+size 11939

errors_by_mech.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a9e8eac7c054dbdb29cd9956bc2c345935fc68cb446398764968c1f31100d9f5
-size 5110
+oid sha256:c71ec8c4f8069ee7e5f82fae7bbcd3f60f32d70d769832888666508ea76417b7
+size 5125

scripts/pull_data.py

@@ -170,10 +170,11 @@ def restoring_trades_data(from_date: str, to_date: str):
 
 
 if __name__ == "__main__":
-    only_new_weekly_analysis()
+    # only_new_weekly_analysis()
     # save_historical_data()
     # try:
     #     clean_old_data_from_parquet_files("2025-01-23")
     # except Exception as e:
     #     print("Error cleaning the oldest information from parquet files")
     #     print(f"reason = {e}")
+    add_current_answer("tools.parquet")

scripts/tools.py

@@ -200,34 +200,49 @@ def parse_json_events(json_events: dict, keys_to_traverse: List[int]) -> pd.Data
                 int(json_input["blockTimestamp"])
             )
             output["tx_hash"] = json_input["transactionHash"]
-            output["prompt_request"] = json_input["ipfsContents"]["prompt"]
-            output["tool"] = json_input["ipfsContents"]["tool"]
-            output["nonce"] = json_input["ipfsContents"]["nonce"]
-            output["trader_address"] = json_input["sender"]
-            output["deliver_block"] = json_input["deliver"]["blockNumber"]
-            error_value, error_message, prediction_params = get_result_values(
-                json_input["deliver"]["ipfsContents"]["result"]
-            )
-            error_message_value = json_input.get("error_message", error_message)
+            output["prompt_request"] = json_input["ipfsContents"].get("prompt", None)
+            output["tool"] = json_input["ipfsContents"].get("tool", None)
+            output["nonce"] = json_input["ipfsContents"].get("nonce", None)
+            output["trader_address"] = json_input.get("sender", None)
+            output["deliver_block"] = json_input["deliver"].get("blockNumber", None)
+            error_message = json_input.get("error_message", None)
+            error_value = -1
+            if error_message is None:
+                error_value, error_message, prediction_params = get_result_values(
+                    json_input["deliver"]["ipfsContents"]["result"]
+                )
+            # error_message_value = json_input.get("error_message", error_message)
             output["error"] = error_value
-            output["error_message"] = error_message_value
-            output["prompt_response"] = json_input["deliver"]["ipfsContents"]["prompt"]
-            output["mech_address"] = json_input["deliver"]["mech"]
+            output["error_message"] = error_message
+            output["prompt_response"] = json_input["deliver"]["ipfsContents"].get(
+                "prompt", None
+            )
+            output["mech_address"] = json_input["deliver"].get("mech", None)
             p_yes_value, p_no_value, confidence_value, info_utility_value = (
-                get_prediction_values(prediction_params)
+                None,
+                None,
+                None,
+                None,
             )
+            if error_value == 0:
+                p_yes_value, p_no_value, confidence_value, info_utility_value = (
+                    get_prediction_values(prediction_params)
+                )
             output["p_yes"] = p_yes_value
             output["p_no"] = p_no_value
             output["confidence"] = confidence_value
             output["info_utility"] = info_utility_value
             output["vote"] = get_vote(p_yes_value, p_no_value)
-            output["win_probability"] = get_win_probability(p_yes_value, p_no_value)
+            if error_value == 0:
+                output["win_probability"] = get_win_probability(p_yes_value, p_no_value)
+            else:
+                output["win_probability"] = None
             all_records.append(output)
         except Exception as e:
             print(e)
-            print(f"Error parsing the key ={key}. Noted as error")
-            output["error"] = 1
-            output["error_message"] = "Response parsing error"
+            print(f"Error parsing the key ={key}. Noted as mech request error")
+            output["error"] = -1
+            output["error_message"] = "Mech request error"
             output["p_yes"] = None
             output["p_no"] = None
             output["confidence"] = None
@@ -404,10 +419,10 @@ def remove_old_entries(
 
 if __name__ == "__main__":
 
-    # generate_tools_file(
-    #     input_filename="tools_info.json",
-    #     output_filename="tools_updated.parquet",
-    # )
-    remove_old_entries(
-        input_file="tools_info.json", output_file="cleaned_tools_info.json"
+    generate_tools_file(
+        input_filename="tools_info.json",
+        output_filename="tools_updated.parquet",
     )
+    # remove_old_entries(
+    #     input_file="tools_info.json", output_file="cleaned_tools_info.json"
+    # )

scripts/tools_metrics.py

@@ -8,8 +8,9 @@ def get_error_data_by_market(
 ) -> 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)]
+    mech_tool_errors = tools_inc[tools_inc["error"] != -1]
     error = (
-        tools_inc.groupby(
+        mech_tool_errors.groupby(
             ["tool", "request_month_year_week", "market_creator", "error"], sort=False
         )
         .size()
@@ -27,7 +28,7 @@ def get_tool_winning_rate_by_market(
 ) -> pd.DataFrame:
     """Gets the tool winning rate data for the given tools by market and calculates the winning percentage."""
     tools_inc = tools_df[tools_df["tool"].isin(inc_tools)]
-    tools_non_error = tools_inc[tools_inc["error"] != 1]
+    tools_non_error = tools_inc[tools_inc["error"] == 0]
     tools_non_error.loc[:, "currentAnswer"] = tools_non_error["currentAnswer"].replace(
         {"no": "No", "yes": "Yes"}
     )
@@ -75,6 +76,14 @@ def prepare_tools(tools: pd.DataFrame) -> pd.DataFrame:
     return tools
 
 
+def get_error_category(error_value: int):
+    if error_value == 0:
+        return "non_error"
+    if error_value == 1:
+        return "tool_error"
+    return "request_error"
+
+
 def get_errors_by_mech_address(
     tools_df: pd.DataFrame, inc_tools: List[str]
 ) -> pd.DataFrame:
@@ -88,7 +97,7 @@ def get_errors_by_mech_address(
         .reset_index(name="requests")
     )
     weekly_errors["error_cat"] = weekly_errors["error"].apply(
-        lambda x: "non_error" if x == 0 else "error"
+        lambda x: get_error_category(x)
     )
     total_requests_errors = (
         tools_inc.groupby(["request_month_year_week", "mech_address"], sort=False)
@@ -121,9 +130,11 @@ def compute_tools_based_datasets():
     daily_mech_req_per_tool.to_parquet(
         ROOT_DIR / "daily_mech_requests.parquet", index=False
     )
-    # error by markets
-    error_by_markets = get_error_data_by_market(tools_df=tools_df, inc_tools=INC_TOOLS)
-    error_by_markets.to_parquet(ROOT_DIR / "error_by_markets.parquet", index=False)
+    # mech tool errors by markets
+    tool_error_by_markets = get_error_data_by_market(
+        tools_df=tools_df, inc_tools=INC_TOOLS
+    )
+    tool_error_by_markets.to_parquet(ROOT_DIR / "error_by_markets.parquet", index=False)
     try:
         tools_df = pd.read_parquet(TMP_DIR / "tools.parquet")
         tools_df = prepare_tools(tools_df)
@@ -133,7 +144,7 @@ def compute_tools_based_datasets():
     winning_df = get_tool_winning_rate_by_market(tools_df, inc_tools=INC_TOOLS)
     winning_df.to_parquet(ROOT_DIR / "winning_df.parquet", index=False)
 
-    # errors by mech address
+    # all errors by mech address
     try:
         tools_df = pd.read_parquet(TMP_DIR / "tools.parquet")
         tools_df = prepare_tools(tools_df)

scripts/update_tools_accuracy.py

@@ -18,7 +18,7 @@ def update_tools_accuracy(
     # computation of the accuracy information
     tools_inc = tools_df[tools_df["tool"].isin(inc_tools)]
     # filtering errors
-    tools_non_error = tools_inc[tools_inc["error"] != 1]
+    tools_non_error = tools_inc[tools_inc["error"] == 0]
     tools_non_error.loc[:, "currentAnswer"] = tools_non_error["currentAnswer"].replace(
         {"no": "No", "yes": "Yes"}
     )

scripts/utils.py

@@ -370,23 +370,20 @@ def get_win_probability(p_yes, p_no) -> Optional[float]:
 
 
 def get_result_values(result: str) -> Tuple:
-    if result == "Invalid response":
+    """Function to decide if the result is valid or not"""
+    if isinstance(result, str) and result == "Invalid response":
+        print("Invalid response found")
         return 1, "Invalid response from tool", None
-    error_message = None
-    params = None
+
     try:
         if isinstance(result, str):
             params = json.loads(result)
-            error_value = 0
-
-    except JSONDecodeError:
-        error_message = "Response parsing error"
-        error_value = 1
+            return 0, None, params
 
     except Exception as e:
-        error_message = str(e)
-        error_value = 1
-    return error_value, error_message, params
+        print("Non valid json format")
+
+    return 1, str(result), None
 
 
 def get_prediction_values(params: dict) -> Tuple:

winning_df.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6c58823f7d3b04e4958da7935af6c6c111f4194e719642eccd1d3cd9870bed42
-size 11337
+oid sha256:43e6d3c7367771c0816f3f007eb9f3afd13f160abe14411a7d8f154cc157651a
+size 11807