prediction-market-agent-tooling 0.66.0.dev791__tar.gz → 0.66.2__tar.gz

{prediction_market_agent_tooling-0.66.0.dev791 → prediction_market_agent_tooling-0.66.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.66.0.dev791
+Version: 0.66.2
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13
@@ -14,7 +14,7 @@ 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: cowdao-cowpy-kongzii (==1.0.0rc2)
+Requires-Dist: cowdao-cowpy (==1.0.0rc5)
 Requires-Dist: cron-validator (>=1.0.8,<2.0.0)
 Requires-Dist: eth-account (>=0.8.0,<0.12.0)
 Requires-Dist: eth-keys (>=0.6.1,<0.7.0)

{prediction_market_agent_tooling-0.66.0.dev791 → prediction_market_agent_tooling-0.66.2}/prediction_market_agent_tooling/deploy/agent.py

@@ -571,7 +571,9 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         Given the market and prediction, agent uses this method to calculate optimal outcome and bet size.
         """
         total_amount = self.get_total_amount_to_bet(market)
-        return MultiCategoricalMaxAccuracyBettingStrategy(bet_amount=total_amount)
+        return MultiCategoricalMaxAccuracyBettingStrategy(
+            max_position_amount=total_amount
+        )
 
     def build_trades(
         self,

{prediction_market_agent_tooling-0.66.0.dev791 → prediction_market_agent_tooling-0.66.2}/prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -1,6 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import Sequence
 
+import numpy as np
 from scipy.optimize import minimize_scalar
 
 from prediction_market_agent_tooling.benchmark.utils import get_most_probable_outcome
@@ -94,6 +95,76 @@ class BettingStrategy(ABC):
         )
         return trades
 
+    @staticmethod
+    def cap_to_profitable_bet_amount(
+        market: AgentMarket,
+        bet_amount: USD,
+        outcome: OutcomeStr,
+        iters: int = 10,
+    ) -> USD:
+        """
+        Use a binary search (tree-based search) to efficiently find the largest profitable bet amount.
+        """
+        # First, try it with the desired amount right away.
+        if (
+            market.get_in_usd(
+                check_not_none(
+                    market.get_buy_token_amount(bet_amount, outcome)
+                ).as_token
+            )
+            > bet_amount
+        ):
+            return bet_amount
+
+        # If it wasn't profitable, try binary search to find the highest, but profitable, amount.
+        lower = USD(0)
+        # It doesn't make sense to try to bet more than the liquidity itself, so override it as maximal value if it's lower.
+        upper = min(bet_amount, market.get_in_usd(market.get_liquidity()))
+        best_profitable = USD(0)
+
+        for _ in range(iters):
+            mid = (lower + upper) / 2
+            potential_outcome_value = market.get_in_usd(
+                check_not_none(market.get_buy_token_amount(mid, outcome)).as_token
+            )
+
+            if potential_outcome_value > mid:
+                # Profitable, try higher
+                best_profitable = mid
+                lower = mid
+
+            else:
+                # Not profitable, try lower
+                upper = mid
+
+            # If the search interval is very small, break early
+            if float(upper - lower) < 1e-8:
+                break
+
+        if np.isclose(best_profitable.value, 0):
+            best_profitable = USD(0)
+
+        return best_profitable
+
+    @staticmethod
+    def cap_to_profitable_position(
+        market: AgentMarket,
+        existing_position: USD,
+        wanted_position: USD,
+        outcome_to_bet_on: OutcomeStr,
+    ) -> USD:
+        # If the wanted position is lower, it means the agent is gonna sell and that's profitable always.
+        if wanted_position > existing_position:
+            difference = wanted_position - existing_position
+            # Cap the difference we would like to buy to a profitable one.
+            capped_difference = BettingStrategy.cap_to_profitable_bet_amount(
+                market, difference, outcome_to_bet_on
+            )
+            # Lowered the actual wanted position such that it remains profitable.
+            wanted_position = existing_position + capped_difference
+
+        return wanted_position
+
     def _build_rebalance_trades_from_positions(
         self,
         existing_position: ExistingPosition | None,
@@ -160,12 +231,12 @@ class BettingStrategy(ABC):
 
 
 class MultiCategoricalMaxAccuracyBettingStrategy(BettingStrategy):
-    def __init__(self, bet_amount: USD):
-        self.bet_amount = bet_amount
+    def __init__(self, max_position_amount: USD):
+        self.max_position_amount = max_position_amount
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
-        return self.bet_amount
+        return self.max_position_amount
 
     @staticmethod
     def calculate_direction(
@@ -196,11 +267,23 @@ class MultiCategoricalMaxAccuracyBettingStrategy(BettingStrategy):
         market: AgentMarket,
     ) -> list[Trade]:
         """We place bet on only one outcome."""
-
         outcome_to_bet_on = self.calculate_direction(market, answer)
 
+        # Will be lowered if the amount that we would need to buy would be unprofitable.
+        actual_wanted_position = BettingStrategy.cap_to_profitable_position(
+            market,
+            (
+                existing_position.amounts_current.get(outcome_to_bet_on, USD(0))
+                if existing_position
+                else USD(0)
+            ),
+            self.max_position_amount,
+            outcome_to_bet_on,
+        )
+
         target_position = Position(
-            market_id=market.id, amounts_current={outcome_to_bet_on: self.bet_amount}
+            market_id=market.id,
+            amounts_current={outcome_to_bet_on: actual_wanted_position},
         )
         trades = self._build_rebalance_trades_from_positions(
             existing_position=existing_position,
@@ -253,13 +336,13 @@ class MaxExpectedValueBettingStrategy(MultiCategoricalMaxAccuracyBettingStrategy
 
 
 class KellyBettingStrategy(BettingStrategy):
-    def __init__(self, max_bet_amount: USD, max_price_impact: float | None = None):
-        self.max_bet_amount = max_bet_amount
+    def __init__(self, max_position_amount: USD, max_price_impact: float | None = None):
+        self.max_position_amount = max_position_amount
         self.max_price_impact = max_price_impact
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
-        return self.max_bet_amount
+        return self.max_position_amount
 
     @staticmethod
     def get_kelly_bet(
@@ -321,7 +404,7 @@ class KellyBettingStrategy(BettingStrategy):
 
         kelly_bet = self.get_kelly_bet(
             market=market,
-            max_bet_amount=self.max_bet_amount,
+            max_bet_amount=self.max_position_amount,
             direction=direction,
             other_direction=other_direction,
             answer=answer,
@@ -405,16 +488,16 @@ class KellyBettingStrategy(BettingStrategy):
         return CollateralToken(optimized_bet_amount.x)
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_bet_amount={self.max_bet_amount}, max_price_impact={self.max_price_impact})"
+        return f"{self.__class__.__name__}(max_bet_amount={self.max_position_amount}, max_price_impact={self.max_price_impact})"
 
 
 class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
-    def __init__(self, max_bet_amount: USD):
-        self.max_bet_amount = max_bet_amount
+    def __init__(self, max_position_amount: USD):
+        self.max_position_amount = max_position_amount
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
-        return self.max_bet_amount
+        return self.max_position_amount
 
     def adjust_bet_amount(
         self, existing_position: ExistingPosition | None, market: AgentMarket
@@ -422,7 +505,7 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         existing_position_total_amount = (
             existing_position.total_amount_current if existing_position else USD(0)
         )
-        return self.max_bet_amount + existing_position_total_amount
+        return self.max_position_amount + existing_position_total_amount
 
     def calculate_trades(
         self,
@@ -471,4 +554,4 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         return trades
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_bet_amount={self.max_bet_amount})"
+        return f"{self.__class__.__name__}(max_bet_amount={self.max_position_amount})"

{prediction_market_agent_tooling-0.66.0.dev791 → prediction_market_agent_tooling-0.66.2}/prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -93,7 +93,7 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
 
     def get_job_trade(self, max_bond: USD, result: str) -> Trade:
         # Because jobs are powered by prediction markets, potentional reward depends on job's liquidity and our will to bond (bet) our xDai into our job completion.
-        strategy = KellyBettingStrategy(max_bet_amount=max_bond)
+        strategy = KellyBettingStrategy(max_position_amount=max_bond)
         required_trades = strategy.calculate_trades(
             existing_position=None,
             answer=self.get_job_answer(result),

{prediction_market_agent_tooling-0.66.0.dev791 → prediction_market_agent_tooling-0.66.2}/prediction_market_agent_tooling/markets/data_models.py

@@ -15,7 +15,7 @@ from prediction_market_agent_tooling.gtypes import (
     Probability,
 )
 from prediction_market_agent_tooling.logprobs_parser import FieldLogprobs
-from prediction_market_agent_tooling.markets.omen.omen import (
+from prediction_market_agent_tooling.markets.omen.omen_constants import (
     OMEN_FALSE_OUTCOME,
     OMEN_TRUE_OUTCOME,
 )

{prediction_market_agent_tooling-0.66.0.dev791 → prediction_market_agent_tooling-0.66.2}/prediction_market_agent_tooling/markets/metaculus/data_models.py

@@ -14,13 +14,13 @@ class QuestionType(str, Enum):
 class AggregationItem(BaseModel):
     start_time: DatetimeUTC
     end_time: DatetimeUTC | None
-    forecast_values: list[float] | None
+    forecast_values: list[float] | None = None
     forecaster_count: int
     interval_lower_bounds: list[float] | None
     centers: list[float] | None
     interval_upper_bounds: list[float] | None
-    means: list[float] | None
-    histogram: list[list[float]] | None
+    means: list[float] | None = None
+    histogram: list[list[float]] | None = None
 
 
 class Aggregation(BaseModel):

{prediction_market_agent_tooling-0.66.0.dev791 → prediction_market_agent_tooling-0.66.2}/prediction_market_agent_tooling/markets/omen/cow_contracts.py

@@ -3,7 +3,7 @@ import os
 from web3 import Web3
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import ABI, HexBytes
+from prediction_market_agent_tooling.gtypes import ABI, ChecksumAddress, HexBytes
 from prediction_market_agent_tooling.tools.contract import (
     ContractOnGnosisChain,
     abi_field_validator,
@@ -19,6 +19,10 @@ class CowGPv2SettlementContract(ContractOnGnosisChain):
         )
     )
 
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0x9008D19f58AAbD9eD0D60971565AA8510560ab41"
+    )
+
     def setPreSignature(
         self,
         api_keys: APIKeys,

{prediction_market_agent_tooling-0.66.0.dev791 → prediction_market_agent_tooling-0.66.2}/prediction_market_agent_tooling/markets/omen/data_models.py

@@ -23,6 +23,10 @@ from prediction_market_agent_tooling.markets.data_models import (
     Resolution,
     ResolvedBet,
 )
+from prediction_market_agent_tooling.markets.omen.omen_constants import (
+    OMEN_FALSE_OUTCOME,
+    OMEN_TRUE_OUTCOME,
+)
 from prediction_market_agent_tooling.tools.contract import (
     ContractERC20OnGnosisChain,
     init_collateral_token_contract,
@@ -37,8 +41,6 @@ from prediction_market_agent_tooling.tools.utils import (
     utcnow,
 )
 
-OMEN_TRUE_OUTCOME = OutcomeStr("Yes")
-OMEN_FALSE_OUTCOME = OutcomeStr("No")
 OMEN_BINARY_MARKET_OUTCOMES: t.Sequence[OutcomeStr] = [
     OMEN_TRUE_OUTCOME,
     OMEN_FALSE_OUTCOME,

{prediction_market_agent_tooling-0.66.0.dev791 → prediction_market_agent_tooling-0.66.2}/prediction_market_agent_tooling/markets/omen/omen.py

@@ -104,6 +104,7 @@ class OmenAgentMarket(AgentMarket):
 
     collateral_token_contract_address_checksummed: ChecksumAddress
     market_maker_contract_address_checksummed: ChecksumAddress
+    outcome_token_pool: dict[OutcomeStr, OutcomeToken]
     condition: Condition
     finalized_time: DatetimeUTC | None
     created_time: DatetimeUTC
@@ -620,11 +621,10 @@ class OmenAgentMarket(AgentMarket):
         Note: this is only valid if the market instance's token pool is
         up-to-date with the smart contract.
         """
-        outcome_token_pool = check_not_none(self.outcome_token_pool)
         amount = get_buy_outcome_token_amount(
             investment_amount=self.get_in_token(bet_amount),
             outcome_index=self.get_outcome_index(outcome),
-            pool_balances=[outcome_token_pool[x] for x in self.outcomes],
+            pool_balances=[self.outcome_token_pool[x] for x in self.outcomes],
             fees=self.fees,
         )
         return amount

{prediction_market_agent_tooling-0.66.0.dev791 → prediction_market_agent_tooling-0.66.2}/prediction_market_agent_tooling/markets/omen/omen_constants.py

@@ -1,5 +1,10 @@
 from web3 import Web3
 
+from prediction_market_agent_tooling.gtypes import OutcomeStr
+
+OMEN_TRUE_OUTCOME = OutcomeStr("Yes")
+OMEN_FALSE_OUTCOME = OutcomeStr("No")
+
 WRAPPED_XDAI_CONTRACT_ADDRESS = Web3.to_checksum_address(
     "0xe91d153e0b41518a2ce8dd3d7944fa863463a97d"
 )

{prediction_market_agent_tooling-0.66.0.dev791 → prediction_market_agent_tooling-0.66.2}/prediction_market_agent_tooling/markets/seer/seer.py

@@ -2,6 +2,7 @@ import asyncio
 import typing as t
 from datetime import timedelta
 
+from cowdao_cowpy.common.api.errors import UnexpectedResponseError
 from eth_typing import ChecksumAddress
 from web3 import Web3
 from web3.types import TxReceipt
@@ -61,7 +62,6 @@ from prediction_market_agent_tooling.tools.contract import (
     to_gnosis_chain_contract,
 )
 from prediction_market_agent_tooling.tools.cow.cow_order import (
-    cancel_order,
     get_buy_token_amount_else_raise,
     get_orders_by_owner,
     get_trades_by_owner,
@@ -198,9 +198,7 @@ class SeerAgentMarket(AgentMarket):
                 )
             )
 
-            amounts_ot[
-                OutcomeStr(outcome_str)
-            ] = outcome_token_balance_wei.as_outcome_token
+            amounts_ot[outcome_str] = outcome_token_balance_wei.as_outcome_token
 
         amounts_current = {
             k: self.get_token_in_usd(self.get_sell_value_of_outcome_token(k, v))
@@ -481,26 +479,32 @@ class SeerAgentMarket(AgentMarket):
         Returns:
             Transaction hash of the successful swap
         """
-        _, order = swap_tokens_waiting(
-            amount_wei=amount_wei,
-            sell_token=sell_token,
-            buy_token=buy_token,
-            api_keys=api_keys,
-            web3=web3,
-            wait_order_complete=False,
-        )
 
         try:
+            _, order = swap_tokens_waiting(
+                amount_wei=amount_wei,
+                sell_token=sell_token,
+                buy_token=buy_token,
+                api_keys=api_keys,
+                web3=web3,
+                wait_order_complete=False,
+                timeout=timedelta(minutes=2),
+            )
             order_metadata = asyncio.run(wait_for_order_completion(order=order))
             logger.debug(
                 f"Swapped {sell_token} for {buy_token}. Order details {order_metadata}"
             )
             return order_metadata.uid.root
 
-        except TimeoutError:
-            # Since timeout occurred, we need to cancel the order before trying to swap again.
-            asyncio.run(cancel_order(order_uids=[order.uid.root], api_keys=api_keys))
-            logger.info("TimeoutError. Trying to swap directly on Swapr pools.")
+        except (UnexpectedResponseError, TimeoutError) as e:
+            # We don't retry if not enough balance.
+            if "InsufficientBalance" in str(e):
+                raise e
+            # Note that we don't need to cancel the order because we are setting
+            # timeout and valid_to in the order, thus the order simply expires.
+            logger.info(
+                f"Exception occured when swapping tokens via Cowswap, doing swap via pools. {e}"
+            )
 
             tx_receipt = SwapPoolHandler(
                 api_keys=api_keys,

{prediction_market_agent_tooling-0.66.0.dev791 → prediction_market_agent_tooling-0.66.2}/prediction_market_agent_tooling/tools/cow/cow_order.py

@@ -55,7 +55,8 @@ from prediction_market_agent_tooling.markets.omen.cow_contracts import (
 )
 from prediction_market_agent_tooling.tools.contract import ContractERC20OnGnosisChain
 from prediction_market_agent_tooling.tools.cow.models import MinimalisticToken, Order
-from prediction_market_agent_tooling.tools.utils import check_not_none, utcnow
+from prediction_market_agent_tooling.tools.cow.semaphore import postgres_rate_limited
+from prediction_market_agent_tooling.tools.utils import utcnow
 
 
 class OrderStatusError(Exception):
@@ -190,7 +191,11 @@ def handle_allowance(
         )
 
 
+@postgres_rate_limited(
+    api_keys=APIKeys(), rate_id="swap_tokens_waiting", interval_seconds=60.0
+)
 @tenacity.retry(
+    reraise=True,
     stop=stop_after_attempt(3),
     wait=wait_fixed(1),
     retry=tenacity.retry_if_not_exception_type((TimeoutError, OrderStatusError)),
@@ -205,6 +210,7 @@ def swap_tokens_waiting(
     env: Envs = "prod",
     web3: Web3 | None = None,
     wait_order_complete: bool = True,
+    timeout: timedelta = timedelta(seconds=120),
 ) -> tuple[OrderMetaData | None, CompletedOrder]:
     # CoW library uses async, so we need to wrap the call in asyncio.run for us to use it.
     return asyncio.run(
@@ -215,6 +221,7 @@ def swap_tokens_waiting(
             api_keys,
             chain,
             env,
+            timeout=timeout,
             web3=web3,
             wait_order_complete=wait_order_complete,
         )
@@ -229,6 +236,7 @@ async def place_swap_order(
     chain: Chain,
     env: Envs,
     slippage_tolerance: float = 0.01,
+    valid_to: int | None = None,
 ) -> CompletedOrder:
     account = api_keys.get_account()
     safe_address = api_keys.safe_address_checksum
@@ -242,6 +250,7 @@ async def place_swap_order(
         chain=chain,
         env=env,
         slippage_tolerance=slippage_tolerance,
+        valid_to=valid_to,
     )
     logger.info(f"Order created: {order}")
 
@@ -299,6 +308,7 @@ async def swap_tokens_waiting_async(
     handle_allowance(
         api_keys=api_keys, sell_token=sell_token, amount_wei=amount_wei, web3=web3
     )
+    valid_to = (utcnow() + timeout).timestamp()
     order = await place_swap_order(
         api_keys=api_keys,
         amount_wei=amount_wei,
@@ -307,6 +317,7 @@ async def swap_tokens_waiting_async(
         chain=chain,
         env=env,
         slippage_tolerance=slippage_tolerance,
+        valid_to=int(valid_to),
     )
     if wait_order_complete:
         order_metadata = await wait_for_order_completion(order=order, timeout=timeout)
@@ -327,11 +338,8 @@ async def sign_safe_cow_swap(
 ) -> None:
     order_book_api = get_order_book_api(env, chain)
     posted_order = await order_book_api.get_order_by_uid(order.uid)
-    CowGPv2SettlementContract(
-        address=Web3.to_checksum_address(
-            check_not_none(posted_order.settlementContract).root
-        )
-    ).setPreSignature(
+
+    CowGPv2SettlementContract().setPreSignature(
         api_keys,
         HexBytes(posted_order.uid.root),
         True,

{prediction_market_agent_tooling-0.66.0.dev791 → prediction_market_agent_tooling-0.66.2}/prediction_market_agent_tooling/tools/cow/models.py

@@ -1,7 +1,9 @@
 from pydantic import BaseModel
+from sqlmodel import Field, SQLModel
 
 from prediction_market_agent_tooling.gtypes import ChecksumAddress
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.utils import utcnow
 
 
 class MinimalisticToken(BaseModel):
@@ -14,3 +16,9 @@ class Order(BaseModel):
     sellToken: str
     buyToken: str
     creationDate: DatetimeUTC
+
+
+class RateLimit(SQLModel, table=True):
+    __tablename__ = "rate_limit"
+    id: str = Field(primary_key=True)
+    last_called_at: DatetimeUTC = Field(default_factory=utcnow)

prediction_market_agent_tooling-0.66.2/prediction_market_agent_tooling/tools/cow/semaphore.py

@@ -0,0 +1,101 @@
+import time
+from datetime import timedelta
+from functools import wraps
+from typing import Any, Callable, Optional, TypeVar, cast
+
+from sqlalchemy.exc import OperationalError
+from sqlmodel import Session, select
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.tools.cow.models import RateLimit
+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
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+FALLBACK_SQL_ENGINE = "sqlite:///rate_limit.db"
+
+
+def postgres_rate_limited(
+    api_keys: APIKeys, rate_id: str = "default", interval_seconds: float = 1.0
+) -> Callable[[F], F]:
+    """rate_id is used to distinguish between different rate limits for different functions"""
+    limiter = RateLimiter(id=rate_id, interval_seconds=interval_seconds)
+
+    def decorator(func: F) -> F:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            sqlalchemy_db_url = (
+                api_keys.sqlalchemy_db_url.get_secret_value()
+                if api_keys.SQLALCHEMY_DB_URL
+                else FALLBACK_SQL_ENGINE
+            )
+
+            db_manager = DBManager(sqlalchemy_db_url)
+            db_manager.create_tables([RateLimit])
+
+            with db_manager.get_session() as session:
+                limiter.enforce(session)
+            return func(*args, **kwargs)
+
+        return cast(F, wrapper)
+
+    return decorator
+
+
+class RateLimiter:
+    def __init__(self, id: str, interval_seconds: float = 1.0) -> None:
+        self.id = id
+        self.interval = timedelta(seconds=interval_seconds)
+
+    def enforce(self, session: Session, timeout_seconds: float = 30.0) -> None:
+        """
+        Enforces the rate limit inside a transaction.
+        Blocks until allowed or timeout is reached.
+
+        Args:
+            session: The database session to use
+            timeout_seconds: Maximum time in seconds to wait before giving up
+
+        Raises:
+            TimeoutError: If the rate limit cannot be acquired within the timeout period
+        """
+        start_time = time.monotonic()
+
+        while True:
+            try:
+                with session.begin():
+                    stmt = (
+                        select(RateLimit)
+                        .where(RateLimit.id == self.id)
+                        .with_for_update()
+                    )
+                    result: Optional[RateLimit] = session.exec(stmt).first()
+
+                    now = utcnow()
+
+                    if result is None:
+                        # First time this limiter is used
+                        session.add(RateLimit(id=self.id))
+                        return
+
+                    last_called_aware = DatetimeUTC.from_datetime(result.last_called_at)
+                    elapsed = now - last_called_aware
+                    if elapsed >= self.interval:
+                        result.last_called_at = now
+                        session.add(result)
+                        return
+
+                    # Not enough time passed, sleep and retry
+                    to_sleep = (self.interval - elapsed).total_seconds()
+                    time.sleep(to_sleep)
+            except OperationalError:
+                # Backoff if DB is under contention
+                elapsed_time = time.monotonic() - start_time
+                if elapsed_time > timeout_seconds:
+                    raise TimeoutError(
+                        f"Could not acquire rate limit '{self.id}' "
+                        f"after {elapsed_time:.1f} seconds due to database contention"
+                    )
+                time.sleep(0.5)

{prediction_market_agent_tooling-0.66.0.dev791 → prediction_market_agent_tooling-0.66.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "prediction-market-agent-tooling"
-version = "0.66.0.dev791"
+version = "0.66.2"
 description = "Tools to benchmark, deploy and monitor prediction market agents."
 authors = ["Gnosis"]
 readme = "README.md"
@@ -55,7 +55,7 @@ hishel = "^0.0.31"
 pytest-postgresql = "^6.1.1"
 optuna = { version = "^4.1.0", optional = true}
 httpx = ">=0.25.2,<1.0.0"
-cowdao-cowpy-kongzii = "1.0.0rc2" # Use `cowdao-cowpy` once they release latest version.
+cowdao-cowpy = "1.0.0rc5"
 eth-keys = "^0.6.1"
 proto-plus = "^1.0.0"
 protobuf = "^5.0.0"