prediction-market-agent-tooling 0.57.0__py3-none-any.whl → 0.57.2__py3-none-any.whl

prediction_market_agent_tooling/config.py

@@ -188,14 +188,14 @@ class APIKeys(BaseSettings):
         return {
             k: v
             for k, v in self.model_dump().items()
-            if APIKeys.model_fields[k].annotation not in SECRET_TYPES and v is not None
+            if self.model_fields[k].annotation not in SECRET_TYPES and v is not None
         }
 
     def model_dump_secrets(self) -> dict[str, t.Any]:
         return {
             k: v.get_secret_value() if isinstance(v, SecretStr) else v
             for k, v in self.model_dump().items()
-            if APIKeys.model_fields[k].annotation in SECRET_TYPES and v is not None
+            if self.model_fields[k].annotation in SECRET_TYPES and v is not None
         }
 
     def check_if_is_safe_owner(self, ethereum_client: EthereumClient) -> bool:

prediction_market_agent_tooling/markets/base_subgraph_handler.py

@@ -12,8 +12,8 @@ T = t.TypeVar("T", bound=BaseModel)
 
 
 class BaseSubgraphHandler(metaclass=SingletonMeta):
-    def __init__(self) -> None:
-        self.sg = Subgrounds()
+    def __init__(self, timeout: int = 30) -> None:
+        self.sg = Subgrounds(timeout=timeout)
         # Patch methods to retry on failure.
         self.sg.query_json = tenacity.retry(
             stop=tenacity.stop_after_attempt(3),

prediction_market_agent_tooling/markets/data_models.py

@@ -142,7 +142,7 @@ class PlacedTrade(Trade):
         )
 
 
-class SimulationDetail(BaseModel):
+class SimulatedBetDetail(BaseModel):
     strategy: str
     url: str
     market_p_yes: float
@@ -161,3 +161,16 @@ class SharpeOutput(BaseModel):
     annualized_volatility: float
     mean_daily_return: float
     annualized_sharpe_ratio: float
+
+
+class SimulatedLifetimeDetail(BaseModel):
+    p_yes_mse: float
+    total_bet_amount: float
+    total_bet_profit: float
+    total_simulated_amount: float
+    total_simulated_profit: float
+    roi: float
+    simulated_roi: float
+    sharpe_output_original: SharpeOutput
+    sharpe_output_simulation: SharpeOutput
+    maximize: float

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -42,6 +42,10 @@ PRESAGIO_BASE_URL = "https://presagio.pages.dev"
 TEST_CATEGORY = "test"  # This category is hidden on Presagio for testing purposes.
 
 
+def construct_presagio_url(market_id: HexAddress) -> str:
+    return f"{PRESAGIO_BASE_URL}/markets?id={market_id}"
+
+
 def get_boolean_outcome(outcome_str: str) -> bool:
     if outcome_str == OMEN_TRUE_OUTCOME:
         return True
@@ -392,7 +396,7 @@ class OmenMarket(BaseModel):
 
     @property
     def url(self) -> str:
-        return f"{PRESAGIO_BASE_URL}/markets?id={self.id}"
+        return construct_presagio_url(self.id)
 
     @staticmethod
     def from_created_market(model: "CreatedMarket") -> "OmenMarket":
@@ -499,13 +503,17 @@ class OmenBet(BaseModel):
     creator: OmenBetCreator
     creationTimestamp: int
     collateralAmount: Wei
-    collateralAmountUSD: USD
     feeAmount: Wei
     outcomeIndex: int
     outcomeTokensTraded: Wei
     transactionHash: HexBytes
     fpmm: OmenMarket
 
+    @property
+    def collateral_amount_usd(self) -> USD:
+        # Convert manually instad of using the field `collateralAmountUSD` available on the graph, because it's bugged, it's 0 for non-xDai markets.
+        return USD(wei_to_xdai(self.collateralAmount))
+
     @property
     def creation_datetime(self) -> DatetimeUTC:
         return DatetimeUTC.to_datetime_utc(self.creationTimestamp)
@@ -540,7 +548,7 @@ class OmenBet(BaseModel):
         return Bet(
             id=str(self.transactionHash),
             # Use the transaction hash instead of the bet id - both are valid, but we return the transaction hash from the trade functions, so be consistent here.
-            amount=BetAmount(amount=self.collateralAmountUSD, currency=Currency.xDai),
+            amount=BetAmount(amount=self.collateral_amount_usd, currency=Currency.xDai),
             outcome=self.boolean_outcome,
             created_time=self.creation_datetime,
             market_question=self.title,
@@ -556,7 +564,7 @@ class OmenBet(BaseModel):
         return ResolvedBet(
             id=self.transactionHash.hex(),
             # Use the transaction hash instead of the bet id - both are valid, but we return the transaction hash from the trade functions, so be consistent here.
-            amount=BetAmount(amount=self.collateralAmountUSD, currency=Currency.xDai),
+            amount=BetAmount(amount=self.collateral_amount_usd, currency=Currency.xDai),
             outcome=self.boolean_outcome,
             created_time=self.creation_datetime,
             market_question=self.title,
@@ -775,6 +783,12 @@ class CreatedMarket(BaseModel):
     fee: Wei
     distribution_hint: list[OmenOutcomeToken] | None
 
+    @property
+    def url(self) -> str:
+        return construct_presagio_url(
+            self.market_event.fixed_product_market_maker_checksummed
+        )
+
 
 class ContractPrediction(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
@@ -797,9 +811,13 @@ class ContractPrediction(BaseModel):
         return Web3.to_checksum_address(self.publisher)
 
     @staticmethod
-    def from_tuple(values: tuple[t.Any]) -> "ContractPrediction":
-        data = {k: v for k, v in zip(ContractPrediction.model_fields.keys(), values)}
-        return ContractPrediction.model_validate(data)
+    def from_tuple(values: tuple[t.Any, ...]) -> "ContractPrediction":
+        return ContractPrediction(
+            publisher=values[0],
+            ipfs_hash=values[1],
+            tx_hashes=values[2],
+            estimated_probability_bps=values[3],
+        )
 
 
 class IPFSAgentResult(BaseModel):

prediction_market_agent_tooling/markets/omen/omen.py

@@ -480,6 +480,8 @@ class OmenAgentMarket(AgentMarket):
         better_address: ChecksumAddress,
         start_time: DatetimeUTC,
         end_time: DatetimeUTC | None,
+        market_resolved_before: DatetimeUTC | None = None,
+        market_resolved_after: DatetimeUTC | None = None,
     ) -> list[ResolvedBet]:
         subgraph_handler = OmenSubgraphHandler()
         bets = subgraph_handler.get_resolved_bets_with_valid_answer(
@@ -487,6 +489,8 @@ class OmenAgentMarket(AgentMarket):
             start_time=start_time,
             end_time=end_time,
             market_id=None,
+            market_resolved_before=market_resolved_before,
+            market_resolved_after=market_resolved_after,
         )
         generic_bets = [b.to_generic_resolved_bet() for b in bets]
         return generic_bets

prediction_market_agent_tooling/markets/omen/omen_contracts.py

@@ -538,7 +538,7 @@ class OmenKlerosContract(ContractOnGnosisChain):
             address = "0xe40DD83a262da3f56976038F1554Fe541Fa75ecd"
 
         elif arbitrator == Arbitrator.KLEROS_31_JURORS_WITH_APPEAL:
-            address = "0x29f39de98d750eb77b5fafb31b2837f079fce222"
+            address = "0x5562Ac605764DC4039fb6aB56a74f7321396Cdf2"
 
         else:
             raise ValueError(f"Unsupported arbitrator: {arbitrator=}")

prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -33,6 +33,9 @@ from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     WrappedxDaiContract,
     sDaiContract,
 )
+from prediction_market_agent_tooling.tools.caches.inmemory_cache import (
+    persistent_inmemory_cache,
+)
 from prediction_market_agent_tooling.tools.utils import (
     DatetimeUTC,
     to_int_timestamp,
@@ -112,7 +115,6 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
             bets_field.creator.id,
             bets_field.creationTimestamp,
             bets_field.collateralAmount,
-            bets_field.collateralAmountUSD,
             bets_field.feeAmount,
             bets_field.outcomeIndex,
             bets_field.outcomeTokensTraded,
@@ -524,6 +526,8 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         filter_by_answer_finalized_not_null: bool = False,
         type_: t.Literal["Buy", "Sell"] | None = None,
         market_opening_after: DatetimeUTC | None = None,
+        market_resolved_before: DatetimeUTC | None = None,
+        market_resolved_after: DatetimeUTC | None = None,
         collateral_amount_more_than: Wei | None = None,
         sort_by_field: FieldPath | None = None,
         sort_direction: str | None = None,
@@ -549,6 +553,15 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
             where_stms.append(
                 trade.fpmm.openingTimestamp > to_int_timestamp(market_opening_after)
             )
+        if market_resolved_after is not None:
+            where_stms.append(
+                trade.fpmm.resolutionTimestamp > to_int_timestamp(market_resolved_after)
+            )
+        if market_resolved_before is not None:
+            where_stms.append(
+                trade.fpmm.resolutionTimestamp
+                < to_int_timestamp(market_resolved_before)
+            )
         if collateral_amount_more_than is not None:
             where_stms.append(trade.collateralAmount > collateral_amount_more_than)
 
@@ -577,6 +590,8 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         market_id: t.Optional[ChecksumAddress] = None,
         filter_by_answer_finalized_not_null: bool = False,
         market_opening_after: DatetimeUTC | None = None,
+        market_resolved_before: DatetimeUTC | None = None,
+        market_resolved_after: DatetimeUTC | None = None,
         collateral_amount_more_than: Wei | None = None,
     ) -> list[OmenBet]:
         return self.get_trades(
@@ -587,15 +602,19 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
             filter_by_answer_finalized_not_null=filter_by_answer_finalized_not_null,
             type_="Buy",  # We consider `bet` to be only the `Buy` trade types.
             market_opening_after=market_opening_after,
+            market_resolved_before=market_resolved_before,
+            market_resolved_after=market_resolved_after,
             collateral_amount_more_than=collateral_amount_more_than,
         )
 
     def get_resolved_bets(
         self,
         better_address: ChecksumAddress,
-        start_time: DatetimeUTC,
+        start_time: DatetimeUTC | None = None,
         end_time: t.Optional[DatetimeUTC] = None,
         market_id: t.Optional[ChecksumAddress] = None,
+        market_resolved_before: DatetimeUTC | None = None,
+        market_resolved_after: DatetimeUTC | None = None,
     ) -> list[OmenBet]:
         omen_bets = self.get_bets(
             better_address=better_address,
@@ -603,14 +622,18 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
             end_time=end_time,
             market_id=market_id,
             filter_by_answer_finalized_not_null=True,
+            market_resolved_before=market_resolved_before,
+            market_resolved_after=market_resolved_after,
         )
         return [b for b in omen_bets if b.fpmm.is_resolved]
 
     def get_resolved_bets_with_valid_answer(
         self,
         better_address: ChecksumAddress,
-        start_time: DatetimeUTC,
+        start_time: DatetimeUTC | None = None,
         end_time: t.Optional[DatetimeUTC] = None,
+        market_resolved_before: DatetimeUTC | None = None,
+        market_resolved_after: DatetimeUTC | None = None,
         market_id: t.Optional[ChecksumAddress] = None,
     ) -> list[OmenBet]:
         bets = self.get_resolved_bets(
@@ -618,6 +641,8 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
             start_time=start_time,
             end_time=end_time,
             market_id=market_id,
+            market_resolved_before=market_resolved_before,
+            market_resolved_after=market_resolved_after,
         )
         return [b for b in bets if b.fpmm.is_resolved_with_valid_answer]
 
@@ -926,3 +951,13 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
             raise RuntimeError("Multiple results found for a single bet.")
 
         return results[0]
+
+
+@persistent_inmemory_cache
+def get_omen_market_by_market_id_cached(
+    market_id: HexAddress,
+    block_number: int,  # Force `block_number` to be provided, because `latest` block constantly updates.
+) -> OmenMarket:
+    return OmenSubgraphHandler().get_omen_market_by_market_id(
+        market_id, block_number=block_number
+    )

prediction_market_agent_tooling/monitor/financial_metrics/financial_metrics.py

@@ -3,13 +3,13 @@ import pandas as pd
 
 from prediction_market_agent_tooling.markets.data_models import (
     SharpeOutput,
-    SimulationDetail,
+    SimulatedBetDetail,
 )
 
 
 class SharpeRatioCalculator:
     def __init__(
-        self, details: list[SimulationDetail], risk_free_rate: float = 0.0
+        self, details: list[SimulatedBetDetail], risk_free_rate: float = 0.0
     ) -> None:
         self.details = details
         self.df = pd.DataFrame([d.model_dump() for d in self.details])
@@ -19,7 +19,9 @@ class SharpeRatioCalculator:
         self, required_columns: list[str]
     ) -> None:
         if not set(required_columns).issubset(self.df.columns):
-            raise ValueError("Dataframe doesn't contain all the required columns.")
+            raise ValueError(
+                f"Dataframe doesn't contain all the required columns. {required_columns=} {self.df.columns=}"
+            )
 
     def prepare_wallet_daily_balance_df(
         self, timestamp_col_name: str, profit_col_name: str

prediction_market_agent_tooling/monitor/monitor.py

@@ -223,7 +223,7 @@ def monitor_agent(agent: DeployedAgent) -> None:
         )
         .interactive()
     )
-    st.altair_chart(  # type: ignore # Doesn't expect `LayerChart`, but `Chart`, yet it works.
+    st.altair_chart(
         per_day_accuracy_chart.mark_line()
         + per_day_accuracy_chart.transform_loess("x-axis-day", "Is Correct").mark_line(
             color="red", strokeDash=[5, 5]

prediction_market_agent_tooling/tools/caches/db_cache.py

@@ -1,7 +1,7 @@
 import hashlib
 import inspect
 import json
-from datetime import date, timedelta
+from datetime import timedelta
 from functools import wraps
 from typing import (
     Any,
@@ -17,11 +17,12 @@ from typing import (
 from pydantic import BaseModel
 from sqlalchemy import Column
 from sqlalchemy.dialects.postgresql import JSONB
-from sqlmodel import Field, Session, SQLModel, create_engine, desc, select
+from sqlmodel import Field, SQLModel, desc, select
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.db.db_manager import DBManager
 from prediction_market_agent_tooling.tools.utils import utcnow
 
 FunctionT = TypeVar("FunctionT", bound=Callable[..., Any])
@@ -97,16 +98,7 @@ def db_cache(
         if not api_keys.ENABLE_CACHE:
             return func(*args, **kwargs)
 
-        engine = create_engine(
-            api_keys.sqlalchemy_db_url.get_secret_value(),
-            # Use custom json serializer and deserializer, because otherwise, for example `datetime` serialization would fail.
-            json_serializer=json_serializer,
-            json_deserializer=json_deserializer,
-            pool_size=1,
-        )
-
-        # Create table if it doesn't exist
-        SQLModel.metadata.create_all(engine)
+        DBManager(api_keys).create_tables([FunctionCache])
 
         # Convert *args and **kwargs to a single dictionary, where we have names for arguments passed as args as well.
         signature = inspect.signature(func)
@@ -147,12 +139,11 @@ def db_cache(
 
         # Determine if the function returns or contains Pydantic BaseModel(s)
         return_type = func.__annotations__.get("return", None)
-        is_pydantic_model = False
-
-        if return_type is not None and contains_pydantic_model(return_type):
-            is_pydantic_model = True
+        is_pydantic_model = return_type is not None and contains_pydantic_model(
+            return_type
+        )
 
-        with Session(engine) as session:
+        with DBManager(api_keys).get_session() as session:
             # Try to get cached result
             statement = (
                 select(FunctionCache)
@@ -205,12 +196,11 @@ def db_cache(
                 result=computed_result,
                 created_at=utcnow(),
             )
-            with Session(engine) as session:
+            with DBManager(api_keys).get_session() as session:
                 logger.info(f"Saving {cache_entry} into database.")
                 session.add(cache_entry)
                 session.commit()
 
-        engine.dispose()
         return computed_result
 
     return cast(FunctionT, wrapper)
@@ -230,60 +220,6 @@ def contains_pydantic_model(return_type: Any) -> bool:
     return False
 
 
-def json_serializer_default_fn(
-    y: DatetimeUTC | timedelta | date | BaseModel,
-) -> str | dict[str, Any]:
-    """
-    Used to serialize objects that don't support it by default into a specific string that can be deserialized out later.
-    If this function returns a dictionary, it will be called recursivelly.
-    If you add something here, also add it to `replace_custom_stringified_objects` below.
-    """
-    if isinstance(y, DatetimeUTC):
-        return f"DatetimeUTC::{y.isoformat()}"
-    elif isinstance(y, timedelta):
-        return f"timedelta::{y.total_seconds()}"
-    elif isinstance(y, date):
-        return f"date::{y.isoformat()}"
-    elif isinstance(y, BaseModel):
-        return y.model_dump()
-    raise TypeError(
-        f"Unsuported type for the default json serialize function, value is {y}."
-    )
-
-
-def json_serializer(x: Any) -> str:
-    return json.dumps(x, default=json_serializer_default_fn)
-
-
-def replace_custom_stringified_objects(obj: Any) -> Any:
-    """
-    Used to deserialize objects from `json_serializer_default_fn` into their proper form.
-    """
-    if isinstance(obj, str):
-        if obj.startswith("DatetimeUTC::"):
-            iso_str = obj[len("DatetimeUTC::") :]
-            return DatetimeUTC.to_datetime_utc(iso_str)
-        elif obj.startswith("timedelta::"):
-            total_seconds_str = obj[len("timedelta::") :]
-            return timedelta(seconds=float(total_seconds_str))
-        elif obj.startswith("date::"):
-            iso_str = obj[len("date::") :]
-            return date.fromisoformat(iso_str)
-        else:
-            return obj
-    elif isinstance(obj, dict):
-        return {k: replace_custom_stringified_objects(v) for k, v in obj.items()}
-    elif isinstance(obj, list):
-        return [replace_custom_stringified_objects(item) for item in obj]
-    else:
-        return obj
-
-
-def json_deserializer(s: str) -> Any:
-    data = json.loads(s)
-    return replace_custom_stringified_objects(data)
-
-
 def convert_cached_output_to_pydantic(return_type: Any, data: Any) -> Any:
     """
     Used to initialize Pydantic models from anything cached that was originally a Pydantic model in the output. Including models in nested structures.

prediction_market_agent_tooling/tools/caches/inmemory_cache.py

@@ -1,5 +1,5 @@
 from functools import cache
-from typing import Any, Callable, TypeVar, cast
+from typing import Any, Callable, TypeVar, cast, overload
 
 from joblib import Memory
 
@@ -7,11 +7,51 @@ from prediction_market_agent_tooling.config import APIKeys
 
 MEMORY = Memory(APIKeys().CACHE_DIR, verbose=0)
 
+
 T = TypeVar("T", bound=Callable[..., Any])
 
 
-def persistent_inmemory_cache(func: T) -> T:
+@overload
+def persistent_inmemory_cache(
+    func: None = None,
+    *,
+    in_memory_cache: bool = True,
+) -> Callable[[T], T]:
+    ...
+
+
+@overload
+def persistent_inmemory_cache(
+    func: T,
+    *,
+    in_memory_cache: bool = True,
+) -> T:
+    ...
+
+
+def persistent_inmemory_cache(
+    func: T | None = None,
+    *,
+    in_memory_cache: bool = True,
+) -> T | Callable[[T], T]:
     """
-    Wraps a function with both file cache (for persistent cache) and in-memory cache (for speed).
+    Wraps a function with both file cache (for persistent cache) and optional in-memory cache (for speed).
+    Can be used as @persistent_inmemory_cache or @persistent_inmemory_cache(in_memory_cache=False)
     """
-    return cast(T, cache(MEMORY.cache(func)) if APIKeys().ENABLE_CACHE else func)
+    if func is None:
+        # Ugly Pythonic way to support this decorator as `@persistent_inmemory_cache` but also `@persistent_inmemory_cache(in_memory_cache=False)`
+        def decorator(func: T) -> T:
+            return persistent_inmemory_cache(
+                func,
+                in_memory_cache=in_memory_cache,
+            )
+
+        return decorator
+    else:
+        # The decorator is called without arguments.
+        if not APIKeys().ENABLE_CACHE:
+            return func
+        cached_func = MEMORY.cache(func)
+        if in_memory_cache:
+            cached_func = cache(cached_func)
+        return cast(T, cached_func)

prediction_market_agent_tooling/tools/caches/serializers.py

@@ -0,0 +1,61 @@
+import json
+import typing as t
+from datetime import date, timedelta
+
+from pydantic import BaseModel
+
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+
+
+def json_serializer(x: t.Any) -> str:
+    return json.dumps(x, default=json_serializer_default_fn)
+
+
+def json_serializer_default_fn(
+    y: DatetimeUTC | timedelta | date | BaseModel,
+) -> str | dict[str, t.Any]:
+    """
+    Used to serialize objects that don't support it by default into a specific string that can be deserialized out later.
+    If this function returns a dictionary, it will be called recursivelly.
+    If you add something here, also add it to `replace_custom_stringified_objects` below.
+    """
+    if isinstance(y, DatetimeUTC):
+        return f"DatetimeUTC::{y.isoformat()}"
+    elif isinstance(y, timedelta):
+        return f"timedelta::{y.total_seconds()}"
+    elif isinstance(y, date):
+        return f"date::{y.isoformat()}"
+    elif isinstance(y, BaseModel):
+        return y.model_dump()
+    raise TypeError(
+        f"Unsuported type for the default json serialize function, value is {y}."
+    )
+
+
+def json_deserializer(s: str) -> t.Any:
+    data = json.loads(s)
+    return replace_custom_stringified_objects(data)
+
+
+def replace_custom_stringified_objects(obj: t.Any) -> t.Any:
+    """
+    Used to deserialize objects from `json_serializer_default_fn` into their proper form.
+    """
+    if isinstance(obj, str):
+        if obj.startswith("DatetimeUTC::"):
+            iso_str = obj[len("DatetimeUTC::") :]
+            return DatetimeUTC.to_datetime_utc(iso_str)
+        elif obj.startswith("timedelta::"):
+            total_seconds_str = obj[len("timedelta::") :]
+            return timedelta(seconds=float(total_seconds_str))
+        elif obj.startswith("date::"):
+            iso_str = obj[len("date::") :]
+            return date.fromisoformat(iso_str)
+        else:
+            return obj
+    elif isinstance(obj, dict):
+        return {k: replace_custom_stringified_objects(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [replace_custom_stringified_objects(item) for item in obj]
+    else:
+        return obj

prediction_market_agent_tooling/tools/db/db_manager.py

@@ -0,0 +1,76 @@
+import hashlib
+from contextlib import contextmanager
+from typing import Generator, Sequence
+
+from sqlalchemy import Connection
+from sqlmodel import Session, SQLModel, create_engine
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.tools.caches.serializers import (
+    json_deserializer,
+    json_serializer,
+)
+
+
+class DBManager:
+    _instances: dict[str, "DBManager"] = {}
+
+    def __new__(cls, api_keys: APIKeys | None = None) -> "DBManager":
+        sqlalchemy_db_url = (api_keys or APIKeys()).sqlalchemy_db_url
+        # Hash the secret value to not store secrets in plain text.
+        url_hash = hashlib.md5(
+            sqlalchemy_db_url.get_secret_value().encode()
+        ).hexdigest()
+        # Return singleton per database connection.
+        if url_hash not in cls._instances:
+            instance = super(DBManager, cls).__new__(cls)
+            cls._instances[url_hash] = instance
+        return cls._instances[url_hash]
+
+    def __init__(self, api_keys: APIKeys | None = None) -> None:
+        sqlalchemy_db_url = (api_keys or APIKeys()).sqlalchemy_db_url
+        self._engine = create_engine(
+            sqlalchemy_db_url.get_secret_value(),
+            json_serializer=json_serializer,
+            json_deserializer=json_deserializer,
+            pool_size=20,
+            pool_recycle=3600,
+            echo=True,
+        )
+        self.cache_table_initialized: dict[str, bool] = {}
+
+    @contextmanager
+    def get_session(self) -> Generator[Session, None, None]:
+        with Session(self._engine) as session:
+            yield session
+
+    @contextmanager
+    def get_connection(self) -> Generator[Connection, None, None]:
+        with self.get_session() as session:
+            yield session.connection()
+
+    def create_tables(
+        self, sqlmodel_tables: Sequence[type[SQLModel]] | None = None
+    ) -> None:
+        # Determine tables to create
+        if sqlmodel_tables is not None:
+            tables_to_create = []
+            for sqlmodel_table in sqlmodel_tables:
+                table_name = (
+                    sqlmodel_table.__tablename__()
+                    if callable(sqlmodel_table.__tablename__)
+                    else sqlmodel_table.__tablename__
+                )
+                table = SQLModel.metadata.tables[table_name]
+                if not self.cache_table_initialized.get(table.name):
+                    tables_to_create.append(table)
+        else:
+            tables_to_create = None
+
+        # Create tables in the database
+        SQLModel.metadata.create_all(self._engine, tables=tables_to_create)
+
+        # Update cache to mark tables as initialized
+        if tables_to_create:
+            for table in tables_to_create:
+                self.cache_table_initialized[table.name] = True

prediction_market_agent_tooling/tools/httpx_cached_client.py

@@ -3,7 +3,10 @@ import hishel
 
 class HttpxCachedClient:
     def __init__(self) -> None:
-        storage = hishel.FileStorage(ttl=3600, check_ttl_every=600)
+        storage = hishel.FileStorage(
+            ttl=24 * 60 * 60,
+            check_ttl_every=1 * 60 * 60,
+        )
         controller = hishel.Controller(force_cache=True)
         self.client = hishel.CacheClient(storage=storage, controller=controller)
 

prediction_market_agent_tooling/tools/langfuse_client_utils.py

@@ -63,6 +63,7 @@ def get_traces_for_agent(
     from_timestamp: DatetimeUTC,
     has_output: bool,
     client: Langfuse,
+    to_timestamp: DatetimeUTC | None = None,
 ) -> list[TraceWithDetails]:
     """
     Fetch agent traces using pagination
@@ -76,6 +77,7 @@ def get_traces_for_agent(
             limit=100,
             page=page,
             from_timestamp=from_timestamp,
+            to_timestamp=to_timestamp,
         )
         if not traces.data:
             break

prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_cache.py

@@ -1,10 +1,11 @@
 from datetime import datetime, timedelta
 
 from pydantic import ValidationError
-from sqlmodel import Field, Session, SQLModel, create_engine, desc, select
+from sqlmodel import Field, SQLModel, desc, select
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.tools.db.db_manager import DBManager
 from prediction_market_agent_tooling.tools.relevant_news_analysis.data_models import (
     NoRelevantNews,
     RelevantNews,
@@ -23,33 +24,22 @@ class RelevantNewsCacheModel(SQLModel, table=True):
 
 
 class RelevantNewsResponseCache:
-    def __init__(self, sqlalchemy_db_url: str | None = None):
-        self.engine = create_engine(
-            (
-                sqlalchemy_db_url
-                if sqlalchemy_db_url
-                else APIKeys().sqlalchemy_db_url.get_secret_value()
-            ),
-            pool_size=1,
-        )
+    def __init__(self, api_keys: APIKeys | None = None):
+        self.db_manager = DBManager(api_keys)
         self._initialize_db()
 
     def _initialize_db(self) -> None:
         """
         Creates the tables if they don't exist
         """
-        with self.engine.connect() as conn:
-            SQLModel.metadata.create_all(
-                conn,
-                tables=[SQLModel.metadata.tables[RelevantNewsCacheModel.__tablename__]],
-            )
+        self.db_manager.create_tables([RelevantNewsCacheModel])
 
     def find(
         self,
         question: str,
         days_ago: int,
     ) -> RelevantNews | NoRelevantNews | None:
-        with Session(self.engine) as session:
+        with self.db_manager.get_session() as session:
             query = (
                 select(RelevantNewsCacheModel)
                 .where(RelevantNewsCacheModel.question == question)
@@ -82,7 +72,7 @@ class RelevantNewsResponseCache:
         days_ago: int,
         relevant_news: RelevantNews | None,
     ) -> None:
-        with Session(self.engine) as session:
+        with self.db_manager.get_session() as session:
             cached = RelevantNewsCacheModel(
                 question=question,
                 days_ago=days_ago,

prediction_market_agent_tooling/tools/transaction_cache.py

@@ -9,8 +9,8 @@ from prediction_market_agent_tooling.loggers import logger
 
 class TransactionBlockCache:
     def __init__(self, web3: Web3):
-        self.block_number_cache = dc.Cache("block_cache_dir")
-        self.block_timestamp_cache = dc.Cache("timestamp_cache_dir")
+        self.block_number_cache = dc.Cache(".cache/block_cache_dir")
+        self.block_timestamp_cache = dc.Cache(".cache/timestamp_cache_dir")
         self.web3 = web3
 
     @tenacity.retry(

{prediction_market_agent_tooling-0.57.0.dist-info → prediction_market_agent_tooling-0.57.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.57.0
+Version: 0.57.2
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.12
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.11
 Provides-Extra: google
 Provides-Extra: langchain
 Provides-Extra: openai
+Provides-Extra: optuna
 Requires-Dist: autoflake (>=2.2.1,<3.0.0)
 Requires-Dist: base58 (>=1.0.2,<2.0)
 Requires-Dist: cron-validator (>=1.0.8,<2.0.0)
@@ -30,6 +31,7 @@ Requires-Dist: loguru (>=0.7.2,<0.8.0)
 Requires-Dist: loky (>=3.4.1,<4.0.0)
 Requires-Dist: numpy (>=1.26.4,<2.0.0)
 Requires-Dist: openai (>=1.0.0,<2.0.0) ; extra == "openai"
+Requires-Dist: optuna (>=4.1.0,<5.0.0) ; extra == "optuna"
 Requires-Dist: pinatapy-vourhey (>=0.2.0,<0.3.0)
 Requires-Dist: prompt-toolkit (>=3.0.43,<4.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.9,<3.0.0)

{prediction_market_agent_tooling-0.57.0.dist-info → prediction_market_agent_tooling-0.57.2.dist-info}/RECORD

@@ -16,7 +16,7 @@ prediction_market_agent_tooling/benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-
 prediction_market_agent_tooling/benchmark/agents.py,sha256=B1-uWdyeN4GGKMWGK_-CcAFJg1m9Y_XuaeIHPB29QR8,3971
 prediction_market_agent_tooling/benchmark/benchmark.py,sha256=MqTiaaJ3cYiOLUVR7OyImLWxcEya3Rl5JyFYW-K0lwM,17097
 prediction_market_agent_tooling/benchmark/utils.py,sha256=D0MfUkVZllmvcU0VOurk9tcKT7JTtwwOp-63zuCBVuc,2880
-prediction_market_agent_tooling/config.py,sha256=13qhBE68CZTnHYVDUxGs4yj_d75WM8QqJVg0a-wAoWA,7559
+prediction_market_agent_tooling/config.py,sha256=Ffb1ftRiguAxa5cS0nXvKK01HomdqzFDCsp8rFd5taM,7553
 prediction_market_agent_tooling/deploy/agent.py,sha256=58Ms6wFcRM3yhpdDVT-ohryZhHJNinn1Z4MdrmCMXvM,23627
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=dIIdZashExWk9tOdyDjw87AuUcGyM7jYxNChYrVK2dM,1001
 prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=kMrIE3wMv_IB6nJd_1DmDXDkEZhsXFOgyTd7JZ0gqHI,13068
@@ -31,9 +31,9 @@ prediction_market_agent_tooling/jobs/jobs_models.py,sha256=GOtsNm7URhzZM5fPY64r8
 prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=N0_jGDyXQeVXXlYg4oA_pOfqIjscHsLQbr0pBwFGoRo,5178
 prediction_market_agent_tooling/loggers.py,sha256=Am6HHXRNO545BO3l7Ue9Wb2TkYE1OK8KKhGbI3XypVU,3751
 prediction_market_agent_tooling/markets/agent_market.py,sha256=W2ME57-CSAhrt8qm8-b5r7yLq-Sk7R_BZMaApvjhrUE,12901
-prediction_market_agent_tooling/markets/base_subgraph_handler.py,sha256=IxDTwX4tej9j5olNkXcLIE0RCF1Nh2icZQUT2ERMmZo,1937
+prediction_market_agent_tooling/markets/base_subgraph_handler.py,sha256=7RaYO_4qAmQ6ZGM8oPK2-CkiJfKmV9MxM-rJlduaecU,1971
 prediction_market_agent_tooling/markets/categorize.py,sha256=jsoHWvZk9pU6n17oWSCcCxNNYVwlb_NXsZxKRI7vmsk,1301
-prediction_market_agent_tooling/markets/data_models.py,sha256=VoEWm338qQMQIRvWpWpDgDjVk9D_3tCHrZPd0Gy0dAA,4033
+prediction_market_agent_tooling/markets/data_models.py,sha256=oMoHxxiNekGgXX1FFExS_MNuHjte2pV1OEynVDIKVc8,4368
 prediction_market_agent_tooling/markets/manifold/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/manifold/api.py,sha256=Fd0HYnstvvHO6AZkp1xiRlvCwQUc8kLR8DAj6PAZu0s,7297
 prediction_market_agent_tooling/markets/manifold/data_models.py,sha256=eiGS4rEkxseZNpEb2BICKnjF0qqgkQTMuUPbSe7_04I,6059
@@ -45,11 +45,11 @@ prediction_market_agent_tooling/markets/metaculus/api.py,sha256=4TRPGytQQbSdf42D
 prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=Suxa7xELdYuFNKqvGvFh8qyfVtAg79E-vaQ6dqNZOtA,3261
 prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=86TIx6cavEWc8Cv4KpZxSvwiSw9oFybXE3YB49pg-CA,4377
 prediction_market_agent_tooling/markets/omen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prediction_market_agent_tooling/markets/omen/data_models.py,sha256=RM5EigkxBArGRAyolgqqHsdIap-FT3FfbvtlWZJwo10,27711
-prediction_market_agent_tooling/markets/omen/omen.py,sha256=6zo8iBBLdI9g9keJ1dw9PXs4rf4V4tCW8D4e08f3g0Q,51349
-prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=Zq7SncCq-hvpgXKsVruGBGCn1OhKZTe7r1qLdCTrT2w,28297
+prediction_market_agent_tooling/markets/omen/data_models.py,sha256=MBaWnUDGjYzbnDOHKPGrhAn0CP7iETVmsulRPqTf00I,28270
+prediction_market_agent_tooling/markets/omen/omen.py,sha256=jrpfeMk8SUwk1p5QWCOm3Qt9HOHsux7DIBm77WRHqW4,51582
+prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=baXJwk-jSI3-FV-k239oCNOA4oKz6LT47juX8AKpW3A,28297
 prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=iDWdjICGkt968exwCjY-6nsnQyrrNAg3YjnDdP430GQ,9415
-prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=lG-2hCmmkjKHX1Ca-SipLBeETnTheXpjg5Qfed0tqFo,36506
+prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=IsnWiVSmaR5I82D49MpJpRu7uE-wkMEgubsLzt0qZVI,38125
 prediction_market_agent_tooling/markets/polymarket/api.py,sha256=UZ4_TG8ceb9Y-qgsOKs8Qiv8zDt957QkT8IX2c83yqo,4800
 prediction_market_agent_tooling/markets/polymarket/data_models.py,sha256=Fd5PI5y3mJM8VHExBhWFWEnuuIKxQmIAXgBuoPDvNjw,4341
 prediction_market_agent_tooling/markets/polymarket/data_models_web.py,sha256=VZhVccTApygSKMmy6Au2G02JCJOKJnR_oVeKlaesuSg,12548
@@ -57,12 +57,12 @@ prediction_market_agent_tooling/markets/polymarket/polymarket.py,sha256=NRoZK71P
 prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=DImFxeMg8lTfsEDZ8FavndW38TfUsCkawcVGnucsuGo,2029
 prediction_market_agent_tooling/markets/seer/data_models.py,sha256=2f6DOXhGerYbTSk5vUvw_y87TcUxOtSfca8-Et7imtU,643
 prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=Jola8AxmNDljBCzl6Gvjb9qH75Y7D5dAwbdZl_jndN8,5478
-prediction_market_agent_tooling/monitor/financial_metrics/financial_metrics.py,sha256=fEiD-upH7vm5FWSND86r_qW0oV5ZonhaJEBxLK0OZAs,2672
+prediction_market_agent_tooling/monitor/financial_metrics/financial_metrics.py,sha256=fjIgjDIx5MhH5mwf7S0cspLOOSU3elYLhGYoIiM26mU,2746
 prediction_market_agent_tooling/monitor/markets/manifold.py,sha256=TS4ERwTfQnot8dhekNyVNhJYf5ysYsjF-9v5_kM3aVI,3334
 prediction_market_agent_tooling/monitor/markets/metaculus.py,sha256=LOnyWWBFdg10-cTWdb76nOsNjDloO8OfMT85GBzRCFI,1455
 prediction_market_agent_tooling/monitor/markets/omen.py,sha256=EqiJYTvDbSu7fBpbrBmCuf3fc6GHr4MxWrBGa69MIyc,3305
 prediction_market_agent_tooling/monitor/markets/polymarket.py,sha256=wak8o4BYaGbLpshQD12OrsqNABdanyID6ql95lEG2io,1870
-prediction_market_agent_tooling/monitor/monitor.py,sha256=-82COVrQwabUN7N-c8DbotRut9MbYcpfRGo6Cks92d0,14309
+prediction_market_agent_tooling/monitor/monitor.py,sha256=4kMev1iGHQiEFslEqt5bWiXAyM_Qxb4rdMVKx2H9e1U,14235
 prediction_market_agent_tooling/monitor/monitor_app.py,sha256=zNHSwH_KEiv8aOwvfo1JrNuSFMefpzXPWtellhnJpTI,4775
 prediction_market_agent_tooling/monitor/monitor_settings.py,sha256=Xiozs3AsufuJ04JOe1vjUri-IAMWHjjmc2ugGGiHNH4,947
 prediction_market_agent_tooling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -72,37 +72,39 @@ prediction_market_agent_tooling/tools/betting_strategies/market_moving.py,sha256
 prediction_market_agent_tooling/tools/betting_strategies/minimum_bet_to_win.py,sha256=-FUSuQQgjcWSSnoFxnlAyTeilY6raJABJVM2QKkFqAY,438
 prediction_market_agent_tooling/tools/betting_strategies/stretch_bet_between.py,sha256=THMXwFlskvzbjnX_OiYtDSzI8XVFyULWfP2525_9UGc,429
 prediction_market_agent_tooling/tools/betting_strategies/utils.py,sha256=kpIb-ci67Vc1Yqqaa-_S4OUkbhWSIYog4_Iwp69HU_k,97
-prediction_market_agent_tooling/tools/caches/db_cache.py,sha256=yQ5sbccFf75jdj71zmlbJ8z5u2cfQzSRgY4haFG43I0,12712
-prediction_market_agent_tooling/tools/caches/inmemory_cache.py,sha256=tGHHd9HCiE_hCCtPtloHZQdDfBuiow9YsqJNYi2Tx_0,499
+prediction_market_agent_tooling/tools/caches/db_cache.py,sha256=rkA7somZZo5G6OZVvNrCuCVc4kn7TUoPxmOq4J6BZ54,10391
+prediction_market_agent_tooling/tools/caches/inmemory_cache.py,sha256=ZW5iI5rmjqeAebu5T7ftRnlkxiL02IC-MxCfDB80x7w,1506
+prediction_market_agent_tooling/tools/caches/serializers.py,sha256=upSXN5__rmRlzJ6tv1h7FodKzJu9eCkFrN_zeuwroJM,2151
 prediction_market_agent_tooling/tools/contract.py,sha256=Um_nQlpYJRBy4MnNR1CPKESehVwx_w35LwYX6T6py_0,20837
 prediction_market_agent_tooling/tools/costs.py,sha256=EaAJ7v9laD4VEV3d8B44M4u3_oEO_H16jRVCdoZ93Uw,954
 prediction_market_agent_tooling/tools/custom_exceptions.py,sha256=Fh8z1fbwONvP4-j7AmV_PuEcoqb6-QXa9PJ9m7guMcM,93
 prediction_market_agent_tooling/tools/datetime_utc.py,sha256=2JSWF7AXQnv04_D_cu9Vmdkq0TWmGJ1QcK9AeqrA-U8,2765
+prediction_market_agent_tooling/tools/db/db_manager.py,sha256=-WGYY-ZyqPveXb642gw4-Zh-RicMrBFgx7uqCB8TuDg,2801
 prediction_market_agent_tooling/tools/google_utils.py,sha256=t3_UEEvKX3L0biSIQ560GdRbllQ6eprhK_upE243A-0,3185
 prediction_market_agent_tooling/tools/hexbytes_custom.py,sha256=Bp94qgPjvjWf1Vb4lNzGFDXRdThw1rJ91vL6r2PWq5E,2096
-prediction_market_agent_tooling/tools/httpx_cached_client.py,sha256=0-N1r0zcGKlY9Rk-Ab8hbqwc54eMbsoa3jXL0_yCCiM,355
+prediction_market_agent_tooling/tools/httpx_cached_client.py,sha256=RxD-hwtZCMctnMwfzy8t51W9Z9gxFGtDYxBIMChazpc,406
 prediction_market_agent_tooling/tools/image_gen/image_gen.py,sha256=HzRwBx62hOXBOmrtpkXaP9Qq1Ku03uUGdREocyjLQ_k,1266
 prediction_market_agent_tooling/tools/image_gen/market_thumbnail_gen.py,sha256=jgOow4zw6g8dIJrog6Tp-3NQs4wjUJ3VgVKyMQv-0QM,1286
 prediction_market_agent_tooling/tools/ipfs/ipfs_handler.py,sha256=CTTMfTvs_8PH4kAtlQby2aeEKwgpmxtuGbd4oYIdJ2A,1201
 prediction_market_agent_tooling/tools/is_invalid.py,sha256=vuX0TKKhc_7iVnwAjXvfZeFwjr9nyYgREaYQDe-GYgA,5334
 prediction_market_agent_tooling/tools/is_predictable.py,sha256=dSuL8eLnGNKd_MQ3CaT1OuQkAykr3m5kn7f8HHKgDcM,6797
 prediction_market_agent_tooling/tools/langfuse_.py,sha256=jI_4ROxqo41CCnWGS1vN_AeDVhRzLMaQLxH3kxDu3L8,1153
-prediction_market_agent_tooling/tools/langfuse_client_utils.py,sha256=_m5SFnJJy4E0ubvY8ohzEEjES4nMJ_2zfa3wp4x3gSA,5817
+prediction_market_agent_tooling/tools/langfuse_client_utils.py,sha256=83T31s-YbsnNBLyYCjmBI2BBKUEqJUuYFa0uCdkoqy8,5901
 prediction_market_agent_tooling/tools/omen/reality_accuracy.py,sha256=M1SF7iSW1gVlQSTskdVFTn09uPLST23YeipVIWj54io,2236
 prediction_market_agent_tooling/tools/parallelism.py,sha256=6Gou0hbjtMZrYvxjTDFUDZuxmE2nqZVbb6hkg1hF82A,1022
 prediction_market_agent_tooling/tools/relevant_news_analysis/data_models.py,sha256=95l84aztFaxcRLLcRQ46yKJbIlOEuDAbIGLouyliDzA,1316
 prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_analysis.py,sha256=CddJem7tk15NAudJDwmuL8znTycbR-YI8kTNtd3LzG8,5474
-prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_cache.py,sha256=Dcde74ZwoZuohhJ8gIO5GQkdAz1YrAKlvrM8CNgRqWw,3289
+prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_cache.py,sha256=ErLp284YlD7k_M8Si9OT86HuzfmSo1bPlLJtegXx1TA,3011
 prediction_market_agent_tooling/tools/safe.py,sha256=9vxGGLvSPnfy-sxUFDpBTe8omqpGXP7MzvGPp6bRxrU,5197
 prediction_market_agent_tooling/tools/singleton.py,sha256=CiIELUiI-OeS7U7eeHEt0rnVhtQGzwoUdAgn_7u_GBM,729
 prediction_market_agent_tooling/tools/streamlit_user_login.py,sha256=NXEqfjT9Lc9QtliwSGRASIz1opjQ7Btme43H4qJbzgE,3010
 prediction_market_agent_tooling/tools/tavily/tavily_models.py,sha256=5ldQs1pZe6uJ5eDAuP4OLpzmcqYShlIV67kttNFvGS0,342
 prediction_market_agent_tooling/tools/tavily/tavily_search.py,sha256=Kw2mXNkMTYTEe1MBSTqhQmLoeXtgb6CkmHlcAJvhtqE,3809
-prediction_market_agent_tooling/tools/transaction_cache.py,sha256=C96OHkNqPJr_yDiHesSRgekeXIbX62qFl9qldArleuo,1800
+prediction_market_agent_tooling/tools/transaction_cache.py,sha256=K5YKNL2_tR10Iw2TD9fuP-CTGpBbZtNdgbd0B_R7pjg,1814
 prediction_market_agent_tooling/tools/utils.py,sha256=WvuUCHgMCiMq8_wMm5PHNwvLhcdDk2zGKaAM8OUC-qY,6438
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=hWDa7D-jP-iW647t0ATPyiUgKbAq25iH97KUnha25SQ,11944
-prediction_market_agent_tooling-0.57.0.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.57.0.dist-info/METADATA,sha256=yK4VmpYuw1CWWmbpu7cLSWEltKzm-6BMi5vbtI2PTfM,8106
-prediction_market_agent_tooling-0.57.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-prediction_market_agent_tooling-0.57.0.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.57.0.dist-info/RECORD,,
+prediction_market_agent_tooling-0.57.2.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.57.2.dist-info/METADATA,sha256=tzVRrpZtV9Jty0w9XLwxGagZiC3scgqPP6d2cBhqp1A,8188
+prediction_market_agent_tooling-0.57.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+prediction_market_agent_tooling-0.57.2.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.57.2.dist-info/RECORD,,