prediction-market-agent-tooling 0.64.10__py3-none-any.whl → 0.64.11__py3-none-any.whl

prediction_market_agent_tooling/logprobs_parser.py

@@ -1,29 +1,47 @@
 import math
 from itertools import product
-from typing import Any, Tuple
+from typing import Any, Tuple, Type
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
+from pydantic.fields import FieldInfo
+from pydantic.type_adapter import TypeAdapter
 
 from prediction_market_agent_tooling.loggers import logger
 
 
-class LogprobKey(BaseModel):
-    name: str
-    key_type: type
-    valid_values: set[Any] | None
+class LogprobDetail(BaseModel):
+    token: str
+    logprob: float
+    prob: float
+
+
+class FieldLogprobs(BaseModel):
+    key: str
+    logprobs: list[LogprobDetail]
 
 
 class LogprobsParser:
+    def __init__(
+        self,
+        skip_fields: list[str] | None = None,
+        max_top_logprobs_length: int = 3,
+        max_logprobs_length: int = 5,
+    ):
+        base_skip_fields = ["logprobs"]
+        self.skip_fields = base_skip_fields + (skip_fields or [])
+        self.max_top_logprobs_length = max_top_logprobs_length
+        self.max_logprobs_length = max_logprobs_length
+
     def _get_logprobs_key_index(
-        self, logprobs: list[dict[str, Any]], key: LogprobKey
+        self, logprobs: list[dict[str, Any]], field_name: str
     ) -> int:
         key_candidate = ""
         for i, token in enumerate(logprobs):
-            if token["token"] in key.name:
+            if token["token"] in field_name:
                 key_candidate = key_candidate + token["token"]
             else:
                 key_candidate = ""
-            if key_candidate == key.name:
+            if key_candidate == field_name:
                 return i
 
         return -1
@@ -45,19 +63,25 @@ class LogprobsParser:
                 for i in range(result_start_index, len(logprobs))
                 if logprobs[i]["token"] in {",", '"', ",\n", "\",\n'", '",\n'}
             ),
-            -1,
+            len(logprobs) - 1,
         )
         return result_start_index + 1, result_end_index
 
-    def _is_correct_type(self, token: str, key_type: type) -> bool:
+    def _is_correct_type(self, token: str, key_type: type | None) -> bool:
+        if key_type is None:
+            return True
+
         try:
-            key_type(token)
+            TypeAdapter(key_type).validate_python(token)
             return True
-        except ValueError:
+        except ValidationError:
             return False
 
     def _parse_valid_tokens_with__agg_probs(
-        self, logprobs_list: list[tuple[dict[str, Any]]], key: LogprobKey
+        self,
+        logprobs_list: list[tuple[dict[str, Any]]],
+        field_info: FieldInfo,
+        top_logprobs: int,
     ) -> list[dict[str, Any]]:
         results: list[dict[str, Any]] = [
             {
@@ -73,45 +97,59 @@ class LogprobsParser:
         results_filtered: list[dict[str, Any]] = [
             result
             for result in results
-            if self._is_correct_type(result["token"], key.key_type)
-            and (key.valid_values is None or result["token"] in key.valid_values)
+            if self._is_correct_type(result["token"], field_info.annotation)
         ]
 
-        return sorted(results_filtered, key=lambda x: x["logprob"], reverse=True)[
-            : len(logprobs_list[0])
-        ]
+        sorted_results = sorted(
+            results_filtered, key=lambda x: x["logprob"], reverse=True
+        )
+        return (
+            sorted_results[:top_logprobs]
+            if len(sorted_results) > top_logprobs
+            else sorted_results
+        )
 
     def parse_logprobs(
-        self, logprobs: list[dict[str, Any]], keys: list[LogprobKey]
-    ) -> list[dict[str, Any]]:
+        self, logprobs: list[dict[str, Any]], target_model_cls: Type[BaseModel]
+    ) -> list[FieldLogprobs]:
         results_for_keys = []
 
-        for key in keys:
-            key_index = self._get_logprobs_key_index(logprobs, key)
+        for field_name, field_info in target_model_cls.model_fields.items():
+            if field_name in self.skip_fields:
+                continue
+
+            key_index = self._get_logprobs_key_index(logprobs, field_name)
+
             if key_index < 0:
-                logger.warning(f"Key {key.name} not found in logprobs")
+                logger.warning(f"Key {field_name} not found in logprobs")
                 continue
 
             (
                 result_start_index,
                 result_end_index,
             ) = self._get_logprobs_indexes_for_result(logprobs, key_index)
+
             if result_start_index < 0 or result_end_index < 0:
-                logger.warning(f"Error in parsing result for {key.name} in logprobs")
+                logger.warning(f"Error in parsing result for {field_name} in logprobs")
                 continue
 
-            valid_logprobs = [
-                logprobs[i]["top_logprobs"]
+            valid_logprobs_raw = [
+                logprobs[i]["top_logprobs"][: self.max_top_logprobs_length]
                 for i in range(result_start_index, result_end_index)
+                if logprobs[i]["top_logprobs"] is not None
             ]
 
+            parsed_logprobs_data = self._parse_valid_tokens_with__agg_probs(
+                list(product(*valid_logprobs_raw[: self.max_logprobs_length])),
+                field_info,
+                min(len(sublist) for sublist in valid_logprobs_raw),
+            )
+
             results_for_keys.append(
-                {
-                    "key": key.name,
-                    "logprobs": self._parse_valid_tokens_with__agg_probs(
-                        list(product(*valid_logprobs)), key
-                    ),
-                }
+                FieldLogprobs(
+                    key=field_name,
+                    logprobs=[LogprobDetail(**item) for item in parsed_logprobs_data],
+                )
             )
 
         return results_for_keys

prediction_market_agent_tooling/markets/data_models.py

@@ -10,6 +10,7 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeToken,
     Probability,
 )
+from prediction_market_agent_tooling.logprobs_parser import FieldLogprobs
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
 
@@ -77,6 +78,7 @@ class ProbabilisticAnswer(BaseModel):
     p_yes: Probability
     confidence: float
     reasoning: str | None = None
+    logprobs: list[FieldLogprobs] | None = None
 
     @property
     def p_no(self) -> Probability:

{prediction_market_agent_tooling-0.64.10.dist-info → prediction_market_agent_tooling-0.64.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.64.10
+Version: 0.64.11
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13

{prediction_market_agent_tooling-0.64.10.dist-info → prediction_market_agent_tooling-0.64.11.dist-info}/RECORD

@@ -36,12 +36,12 @@ prediction_market_agent_tooling/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeu
 prediction_market_agent_tooling/jobs/jobs_models.py,sha256=8vYafsK1cqMWQtjBoq9rruroF84xAVD00vBTMWH6QMg,2166
 prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=Pf6QxPXGyie-2l_wZUjaGPTjZTlpv50_JhP40mULBaU,5048
 prediction_market_agent_tooling/loggers.py,sha256=hF_n-E5iMSqh3dY5G6LkQRHyReMYGPNTLu82dDFh1PU,5187
-prediction_market_agent_tooling/logprobs_parser.py,sha256=sXIwkA5O_fpBP3Civ891rTa0yRcbs3qNcNsY5MJpL68,3734
+prediction_market_agent_tooling/logprobs_parser.py,sha256=Du1Yc-fAVSixQX_Zx6KWpgSzI_ZYhv5tS1b8IcOPPr8,4979
 prediction_market_agent_tooling/markets/agent_market.py,sha256=1NomilM0GCXcRq_1N_cr2AbSK5ONTowFeRbrhc7V5zE,14929
 prediction_market_agent_tooling/markets/base_subgraph_handler.py,sha256=7RaYO_4qAmQ6ZGM8oPK2-CkiJfKmV9MxM-rJlduaecU,1971
 prediction_market_agent_tooling/markets/blockchain_utils.py,sha256=qm21scopQ6dfewkoqQF6lWLDGg2BblsKUdC9aG93Hmc,2249
 prediction_market_agent_tooling/markets/categorize.py,sha256=jsoHWvZk9pU6n17oWSCcCxNNYVwlb_NXsZxKRI7vmsk,1301
-prediction_market_agent_tooling/markets/data_models.py,sha256=_R9Hr5zwGLpZLPXq0Jo2wZRNRQyOnSi3WVQJZ81syuk,4541
+prediction_market_agent_tooling/markets/data_models.py,sha256=OZdq7VfTenxPk_3mI7DvpGMFMBPrq2pvFwcMb47BnNY,4663
 prediction_market_agent_tooling/markets/manifold/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/manifold/api.py,sha256=ih92UTZdSbmy6tTUgSCps_HqYQXpMSsfne5Np5znVEM,7217
 prediction_market_agent_tooling/markets/manifold/data_models.py,sha256=DWNvK6Qdxz7Lxqpe-qQE4X-mw8GFGpukGfnjT_ohcZA,6364
@@ -125,8 +125,8 @@ prediction_market_agent_tooling/tools/tokens/usd.py,sha256=yuW8iPPtcpP4eLH2nORMD
 prediction_market_agent_tooling/tools/transaction_cache.py,sha256=K5YKNL2_tR10Iw2TD9fuP-CTGpBbZtNdgbd0B_R7pjg,1814
 prediction_market_agent_tooling/tools/utils.py,sha256=AC2a68jwASMWuQi-w8twl8b_M52YwrEJ81abmuEaqMY,6661
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=zRq-eeBGWt8uUGN9G_WfjmJ0eVvO8aWE9S0Pz_Y6AOA,12342
-prediction_market_agent_tooling-0.64.10.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.64.10.dist-info/METADATA,sha256=GsqFlqHhZTBcjYEhPLPMujf8TqDtdPF9z64mwaGT_rc,8742
-prediction_market_agent_tooling-0.64.10.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-prediction_market_agent_tooling-0.64.10.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.64.10.dist-info/RECORD,,
+prediction_market_agent_tooling-0.64.11.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.64.11.dist-info/METADATA,sha256=vhzHKLUHIE1mQ23IjxcxNRrqKulD000OHKJb5RK8erk,8742
+prediction_market_agent_tooling-0.64.11.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+prediction_market_agent_tooling-0.64.11.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.64.11.dist-info/RECORD,,