prediction-market-agent-tooling 0.57.0__py3-none-any.whl → 0.57.1__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/omen/data_models.py

@@ -797,9 +797,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_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/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/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/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-0.57.0.dist-info → prediction_market_agent_tooling-0.57.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.57.0
+Version: 0.57.1
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.12

{prediction_market_agent_tooling-0.57.0.dist-info → prediction_market_agent_tooling-0.57.1.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
@@ -45,9 +45,9 @@ 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/data_models.py,sha256=sUiv8xdccvw15ndgbHIavwz7O_eBxp4wGX2zuuZkd2g,27768
 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/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/polymarket/api.py,sha256=UZ4_TG8ceb9Y-qgsOKs8Qiv8zDt957QkT8IX2c83yqo,4800
@@ -62,7 +62,7 @@ prediction_market_agent_tooling/monitor/markets/manifold.py,sha256=TS4ERwTfQnot8
 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,12 +72,14 @@ 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/db_cache.py,sha256=rkA7somZZo5G6OZVvNrCuCVc4kn7TUoPxmOq4J6BZ54,10391
 prediction_market_agent_tooling/tools/caches/inmemory_cache.py,sha256=tGHHd9HCiE_hCCtPtloHZQdDfBuiow9YsqJNYi2Tx_0,499
+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
@@ -92,7 +94,7 @@ prediction_market_agent_tooling/tools/omen/reality_accuracy.py,sha256=M1SF7iSW1g
 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
@@ -101,8 +103,8 @@ prediction_market_agent_tooling/tools/tavily/tavily_search.py,sha256=Kw2mXNkMTYT
 prediction_market_agent_tooling/tools/transaction_cache.py,sha256=C96OHkNqPJr_yDiHesSRgekeXIbX62qFl9qldArleuo,1800
 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.1.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.57.1.dist-info/METADATA,sha256=dOd_dooUIoLkSfsh7mHctHKfDM1W4fCmqu-Xgr_8gAY,8106
+prediction_market_agent_tooling-0.57.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+prediction_market_agent_tooling-0.57.1.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.57.1.dist-info/RECORD,,