prediction-market-agent-tooling 0.69.7.dev1114__py3-none-any.whl → 0.69.9__py3-none-any.whl

prediction_market_agent_tooling/abis/swapr_quoter.abi.json

@@ -0,0 +1,221 @@
+[
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "_factory",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "_WNativeToken",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "_poolDeployer",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "inputs": [],
+        "name": "WNativeToken",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "int256",
+                "name": "amount0Delta",
+                "type": "int256"
+            },
+            {
+                "internalType": "int256",
+                "name": "amount1Delta",
+                "type": "int256"
+            },
+            {
+                "internalType": "bytes",
+                "name": "path",
+                "type": "bytes"
+            }
+        ],
+        "name": "algebraSwapCallback",
+        "outputs": [],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "factory",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "poolDeployer",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes",
+                "name": "path",
+                "type": "bytes"
+            },
+            {
+                "internalType": "uint256",
+                "name": "amountIn",
+                "type": "uint256"
+            }
+        ],
+        "name": "quoteExactInput",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "amountOut",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint16[]",
+                "name": "fees",
+                "type": "uint16[]"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "tokenIn",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "tokenOut",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "amountIn",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint160",
+                "name": "limitSqrtPrice",
+                "type": "uint160"
+            }
+        ],
+        "name": "quoteExactInputSingle",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "amountOut",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint16",
+                "name": "fee",
+                "type": "uint16"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes",
+                "name": "path",
+                "type": "bytes"
+            },
+            {
+                "internalType": "uint256",
+                "name": "amountOut",
+                "type": "uint256"
+            }
+        ],
+        "name": "quoteExactOutput",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "amountIn",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint16[]",
+                "name": "fees",
+                "type": "uint16[]"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "tokenIn",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "tokenOut",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "amountOut",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint160",
+                "name": "limitSqrtPrice",
+                "type": "uint160"
+            }
+        ],
+        "name": "quoteExactOutputSingle",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "amountIn",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint16",
+                "name": "fee",
+                "type": "uint16"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+]

prediction_market_agent_tooling/markets/seer/data_models.py

@@ -179,6 +179,17 @@ class ExactInputSingleParams(BaseModel):
     )  # 0 for convenience, we also don't expect major price shifts
 
 
+class QuoteExactInputSingleParams(BaseModel):
+    # from https://gnosisscan.io/address/0xcBaD9FDf0D2814659Eb26f600EFDeAF005Eda0F7#writeContract
+    model_config = ConfigDict(populate_by_name=True)
+    token_in: ChecksumAddress = Field(alias="tokenIn")
+    token_out: ChecksumAddress = Field(alias="tokenOut")
+    amount_in: Wei = Field(alias="amountIn")
+    limit_sqrt_price: Wei = Field(
+        alias="limitSqrtPrice", default_factory=lambda: Wei(0)
+    )  # 0 for convenience, we also don't expect major price shifts
+
+
 class SeerTransactionType(str, Enum):
     SWAP = "swap"
     SPLIT = "split"

prediction_market_agent_tooling/markets/seer/price_manager.py

@@ -10,12 +10,17 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeStr,
     OutcomeToken,
     Probability,
+    Wei,
 )
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.seer.data_models import SeerMarket
 from prediction_market_agent_tooling.markets.seer.exceptions import (
     PriceCalculationError,
 )
+from prediction_market_agent_tooling.markets.seer.seer_contracts import (
+    QuoteExactInputSingleParams,
+    SwaprQuoterContract,
+)
 from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
     SeerSubgraphHandler,
 )
@@ -52,16 +57,16 @@ class PriceManager:
             )
 
     def get_price_for_token(self, token: ChecksumAddress) -> CollateralToken | None:
-        return self.get_amount_of_token_in_collateral(token, CollateralToken(1))
+        return self.get_amount_of_token_in_collateral(token, OutcomeToken(1))
 
     @cached(TTLCache(maxsize=100, ttl=5 * 60))
     def get_amount_of_collateral_in_token(
         self,
         token: ChecksumAddress,
         collateral_exchange_amount: CollateralToken,
-    ) -> CollateralToken | None:
+    ) -> OutcomeToken | None:
         if token == self.seer_market.collateral_token_contract_address_checksummed:
-            return collateral_exchange_amount
+            return OutcomeToken(collateral_exchange_amount.value)
 
         try:
             buy_token_amount = get_buy_token_amount_else_raise(
@@ -69,31 +74,31 @@ class PriceManager:
                 sell_token=self.seer_market.collateral_token_contract_address_checksummed,
                 buy_token=token,
             )
-            return buy_token_amount.as_token
+            return OutcomeToken.from_token(buy_token_amount.as_token)
 
         except Exception as e:
             logger.warning(
                 f"Could not get quote for {token=} from Cow, exception {e=}. Falling back to pools. "
             )
-            prices = self.get_token_price_from_pools(token=token)
-            return (
-                prices.priceOfCollateralInAskingToken * collateral_exchange_amount
-                if prices
-                else None
+            quote = self.get_swapr_input_quote(
+                input_token=self.seer_market.collateral_token_contract_address_checksummed,
+                output_token=token,
+                input_amount=collateral_exchange_amount.as_wei,
             )
+            return OutcomeToken.from_token(quote.as_token)
 
     @cached(TTLCache(maxsize=100, ttl=5 * 60))
     def get_amount_of_token_in_collateral(
         self,
         token: ChecksumAddress,
-        token_exchange_amount: CollateralToken,
+        token_exchange_amount: OutcomeToken,
     ) -> CollateralToken | None:
         if token == self.seer_market.collateral_token_contract_address_checksummed:
-            return token_exchange_amount
+            return token_exchange_amount.as_token
 
         try:
             buy_collateral_amount = get_buy_token_amount_else_raise(
-                sell_amount=token_exchange_amount.as_wei,
+                sell_amount=token_exchange_amount.as_outcome_wei.as_wei,
                 sell_token=token,
                 buy_token=self.seer_market.collateral_token_contract_address_checksummed,
             )
@@ -103,17 +108,21 @@ class PriceManager:
             logger.warning(
                 f"Could not get quote for {token=} from Cow, exception {e=}. Falling back to pools. "
             )
-            prices = self.get_token_price_from_pools(token=token)
-            return (
-                prices.priceOfAskingTokenInCollateral * token_exchange_amount
-                if prices
-                else None
+            quote = self.get_swapr_input_quote(
+                input_token=token,
+                output_token=self.seer_market.collateral_token_contract_address_checksummed,
+                input_amount=token_exchange_amount.as_outcome_wei.as_wei,
             )
+            return quote.as_token
 
     def get_token_price_from_pools(
         self,
         token: ChecksumAddress,
     ) -> Prices | None:
+        """
+        Although this might come handy,
+        consider using `get_amount_of_collateral_in_token` or `get_amount_of_token_in_collateral` to have an exact quote.
+        """
         pool = SeerSubgraphHandler().get_pool_by_token(
             token_address=token,
             collateral_address=self.seer_market.collateral_token_contract_address_checksummed,
@@ -248,3 +257,21 @@ class PriceManager:
                 else:
                     probability_map[outcome] = Probability(0)
         return probability_map, outcome_token_pool
+
+    def get_swapr_input_quote(
+        self,
+        input_token: ChecksumAddress,
+        output_token: ChecksumAddress,
+        input_amount: Wei,
+        web3: Web3 | None = None,
+    ) -> Wei:  # Not marked as OutcomeWei, but this works for both buying and selling.
+        quoter = SwaprQuoterContract()
+        amount_out, _ = quoter.quote_exact_input_single(
+            QuoteExactInputSingleParams(
+                token_in=input_token,
+                token_out=output_token,
+                amount_in=input_amount,
+            ),
+            web3=web3,
+        )
+        return amount_out

prediction_market_agent_tooling/markets/seer/seer.py

@@ -159,6 +159,8 @@ class SeerAgentMarket(AgentMarket):
 
     def get_token_in_usd(self, x: CollateralToken) -> USD:
         p = self.get_price_manager()
+        # This function is meant to convert market's collateral token into usd value, however, on Seer, market's collateral can be another's market outcome token.
+        # That's why we need this middle step.
         sdai_amount = p.get_amount_of_collateral_in_token(
             # Hard-coded SDAI, because Seer is atm hard-coded it as well, and it's needed in case of fallback to pools. CoW would work with other tokens as well.
             SDAI_CONTRACT_ADDRESS,
@@ -168,14 +170,16 @@ class SeerAgentMarket(AgentMarket):
             raise RuntimeError(
                 "Both CoW and pool-fallback way of getting price failed."
             )
-        return get_token_in_usd(sdai_amount, SDAI_CONTRACT_ADDRESS)
+        return get_token_in_usd(sdai_amount.as_token, SDAI_CONTRACT_ADDRESS)
 
     def get_usd_in_token(self, x: USD) -> CollateralToken:
         p = self.get_price_manager()
+        # This function is meant to convert market's collateral token into usd value, however, on Seer, market's collateral can be another's market outcome token.
+        # That's why we need this middle step.
         token_amount = p.get_amount_of_token_in_collateral(
             # Hard-coded SDAI, because Seer is atm hard-coded it as well, and it's needed in case of fallback to pools. CoW would work with other tokens as well.
             SDAI_CONTRACT_ADDRESS,
-            get_usd_in_token(x, SDAI_CONTRACT_ADDRESS),
+            OutcomeToken.from_token(get_usd_in_token(x, SDAI_CONTRACT_ADDRESS)),
         )
         if token_amount is None:
             raise RuntimeError(
@@ -205,7 +209,7 @@ class SeerAgentMarket(AgentMarket):
             logger.info(f"Could not get price for token {outcome_token}")
             return None
 
-        return OutcomeToken(amount_outcome_tokens.value)
+        return amount_outcome_tokens
 
     def get_sell_value_of_outcome_token(
         self, outcome: OutcomeStr, amount: OutcomeToken
@@ -217,7 +221,7 @@ class SeerAgentMarket(AgentMarket):
 
         p = self.get_price_manager()
         value_outcome_token_in_collateral = p.get_amount_of_token_in_collateral(
-            wrapped_outcome_token, amount.as_token
+            wrapped_outcome_token, amount
         )
 
         if value_outcome_token_in_collateral is None:
@@ -583,7 +587,7 @@ class SeerAgentMarket(AgentMarket):
                 web3=web3,
             )
             collateral_balance = p.get_amount_of_token_in_collateral(
-                token_address_checksummed, token_balance
+                token_address_checksummed, OutcomeToken.from_token(token_balance)
             )
 
             # We ignore the liquidity in outcome tokens if price unknown.
@@ -688,7 +692,7 @@ class SeerAgentMarket(AgentMarket):
             ).buy_or_sell_outcome_token(
                 token_in=sell_token,
                 token_out=buy_token,
-                amount_wei=amount_wei,
+                amount_in=amount_wei,
                 web3=web3,
             )
             swap_pool_tx_hash = tx_receipt["transactionHash"]

prediction_market_agent_tooling/markets/seer/seer_contracts.py

@@ -15,6 +15,7 @@ from prediction_market_agent_tooling.gtypes import (
 )
 from prediction_market_agent_tooling.markets.seer.data_models import (
     ExactInputSingleParams,
+    QuoteExactInputSingleParams,
 )
 from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
     CreateCategoricalMarketsParams,
@@ -191,3 +192,31 @@ class SwaprRouterContract(ContractOnGnosisChain):
             # Typical Swapr swaps use 150k-300k gas, we set conservative
             default_gas=400_000,
         )
+
+
+class SwaprQuoterContract(ContractOnGnosisChain):
+    # File content taken from https://gnosisscan.io/address/0xcBaD9FDf0D2814659Eb26f600EFDeAF005Eda0F7#code.
+    abi: ABI = abi_field_validator(
+        os.path.join(
+            os.path.dirname(os.path.realpath(__file__)),
+            "../../abis/swapr_quoter.abi.json",
+        )
+    )
+
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0xcBaD9FDf0D2814659Eb26f600EFDeAF005Eda0F7"
+    )
+
+    def quote_exact_input_single(
+        self,
+        params: QuoteExactInputSingleParams,
+        web3: Web3 | None = None,
+    ) -> tuple[Wei, Wei]:
+        # See https://docs.uniswap.org/contracts/v3/guides/swaps/single-swaps.
+        result: tuple[int, int] = self.call(
+            function_name="quoteExactInputSingle",
+            function_params=list(dict(params).values()),
+            web3=web3,
+        )
+        amount_out, fee = result
+        return Wei(amount_out), Wei(fee)

prediction_market_agent_tooling/markets/seer/swap_pool_handler.py

@@ -3,7 +3,6 @@ from web3 import Web3
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
-    CollateralToken,
     HexBytes,
     HexStr,
     TxReceipt,
@@ -36,22 +35,20 @@ class SwapPoolHandler:
 
     def _calculate_amount_out_minimum(
         self,
-        amount_wei: Wei,
+        amount_in: Wei,
         token_in: ChecksumAddress,
-        price_outcome_token: CollateralToken,
+        token_out: ChecksumAddress,
         buffer_pct: float = 0.05,
     ) -> Wei:
-        is_buying_outcome = token_in == self.collateral_token_address
-
-        if is_buying_outcome:
-            value = amount_wei.value * (1.0 - buffer_pct) / price_outcome_token.value
-        else:
-            value = amount_wei.value * price_outcome_token.value * (1.0 - buffer_pct)
-        return Wei(int(value))
+        price_manager = PriceManager.build(HexBytes(HexStr(self.market_id)))
+        value = price_manager.get_swapr_input_quote(
+            input_amount=amount_in, input_token=token_in, output_token=token_out
+        )
+        return value * (1 - buffer_pct)
 
     def buy_or_sell_outcome_token(
         self,
-        amount_wei: Wei,
+        amount_in: Wei,
         token_in: ChecksumAddress,
         token_out: ChecksumAddress,
         web3: Web3 | None = None,
@@ -62,38 +59,22 @@ class SwapPoolHandler:
                 f"trading outcome_token for a token different than collateral_token {self.collateral_token_address} is not supported. {token_in=} {token_out=}"
             )
 
-        outcome_token = (
-            token_in if token_in != self.collateral_token_address else token_out
-        )
-
-        # We could use a quoter contract (https://github.com/SwaprHQ/swapr-sdk/blob/develop/src/entities/trades/swapr-v3/constants.ts#L7), but since there is normally 1 pool per outcome token/collateral pair, it's not necessary.
-
-        price_outcome_token = PriceManager.build(
-            HexBytes(HexStr(self.market_id))
-        ).get_token_price_from_pools(token=outcome_token)
-        if (
-            not price_outcome_token
-            or not price_outcome_token.priceOfCollateralInAskingToken
-        ):
-            raise ValueError(
-                f"Could not find price for {outcome_token=} and {self.collateral_token_address}"
-            )
-
         amount_out_minimum = self._calculate_amount_out_minimum(
-            amount_wei=amount_wei,
+            amount_in=amount_in,
             token_in=token_in,
-            price_outcome_token=price_outcome_token.priceOfCollateralInAskingToken,
+            token_out=token_out,
         )
 
         p = ExactInputSingleParams(
             token_in=token_in,
             token_out=token_out,
             recipient=self.api_keys.bet_from_address,
-            amount_in=amount_wei,
+            amount_in=amount_in,
             amount_out_minimum=amount_out_minimum,
         )
 
         tx_receipt = SwaprRouterContract().exact_input_single(
             api_keys=self.api_keys, params=p, web3=web3
         )
+
         return tx_receipt

prediction_market_agent_tooling/tools/caches/db_cache.py

@@ -1,6 +1,8 @@
+import asyncio
 import hashlib
 import inspect
 import json
+from dataclasses import dataclass
 from datetime import timedelta
 from functools import wraps
 from types import UnionType
@@ -12,6 +14,7 @@ from typing import (
     cast,
     get_args,
     get_origin,
+    get_type_hints,
     overload,
 )
 
@@ -101,136 +104,235 @@ def db_cache(
 
     api_keys = api_keys if api_keys is not None else APIKeys()
 
-    @wraps(func)
-    def wrapper(*args: Any, **kwargs: Any) -> Any:
-        # If caching is disabled, just call the function and return it
-        if not api_keys.ENABLE_CACHE:
-            return func(*args, **kwargs)
+    # Check if the decorated function is async
+    if inspect.iscoroutinefunction(func):
 
-        DBManager(api_keys.sqlalchemy_db_url.get_secret_value()).create_tables(
-            [FunctionCache]
-        )
+        @wraps(func)
+        async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+            # If caching is disabled, just call the function and return it
+            if not api_keys.ENABLE_CACHE:
+                return await func(*args, **kwargs)
 
-        # Convert *args and **kwargs to a single dictionary, where we have names for arguments passed as args as well.
-        signature = inspect.signature(func)
-        bound_arguments = signature.bind(*args, **kwargs)
-        bound_arguments.apply_defaults()
-
-        # Convert any argument that is Pydantic model into classic dictionary, otherwise it won't be json-serializable.
-        args_dict: dict[str, Any] = bound_arguments.arguments
-
-        # Remove `self` or `cls` if present (in case of class' methods)
-        if "self" in args_dict:
-            del args_dict["self"]
-        if "cls" in args_dict:
-            del args_dict["cls"]
-
-        # Remove ignored arguments
-        if ignore_args:
-            for arg in ignore_args:
-                if arg in args_dict:
-                    del args_dict[arg]
-
-        # Remove arguments of ignored types
-        if ignore_arg_types:
-            args_dict = {
-                k: v
-                for k, v in args_dict.items()
-                if not isinstance(v, tuple(ignore_arg_types))
-            }
+            # Run blocking database operations in thread pool
 
-        # Compute a hash of the function arguments used for lookup of cached results
-        arg_string = json.dumps(args_dict, sort_keys=True, default=str)
-        args_hash = hashlib.md5(arg_string.encode()).hexdigest()
+            # Ensure tables in thread pool
+            await asyncio.to_thread(_ensure_tables, api_keys)
 
-        # Get the full function name as concat of module and qualname, to not accidentally clash
-        full_function_name = func.__module__ + "." + func.__qualname__
-        # But also get the standard function name to easily search for it in database
-        function_name = func.__name__
+            ctx = _build_context(func, args, kwargs, ignore_args, ignore_arg_types)
 
-        # Determine if the function returns or contains Pydantic BaseModel(s)
-        return_type = func.__annotations__.get("return", None)
-        is_pydantic_model = return_type is not None and contains_pydantic_model(
-            return_type
-        )
+            # Fetch cached result in thread pool
+            lookup = await asyncio.to_thread(_fetch_cached, api_keys, ctx, max_age)
 
-        with DBManager(
-            api_keys.sqlalchemy_db_url.get_secret_value()
-        ).get_session() as session:
-            # Try to get cached result
-            statement = (
-                select(FunctionCache)
-                .where(
-                    FunctionCache.function_name == function_name,
-                    FunctionCache.full_function_name == full_function_name,
-                    FunctionCache.args_hash == args_hash,
+            if lookup.hit:
+                logger.debug(
+                    f"{DB_CACHE_LOG_PREFIX} [cache-hit] Cache hit for {ctx.full_function_name}"
                 )
-                .order_by(desc(FunctionCache.created_at))
-            )
-            if max_age is not None:
-                cutoff_time = utcnow() - max_age
-                statement = statement.where(FunctionCache.created_at >= cutoff_time)
-            cached_result = session.exec(statement).first()
-
-        if cached_result:
-            logger.info(
-                # Keep the special [case-hit] identifier so we can easily track it in GCP.
-                f"{DB_CACHE_LOG_PREFIX} [cache-hit] Cache hit for {full_function_name} with args {args_dict} and output {cached_result.result}"
+                return lookup.value
+
+            computed_result = await func(*args, **kwargs)
+            logger.debug(
+                f"{DB_CACHE_LOG_PREFIX} [cache-miss] Cache miss for {ctx.full_function_name}"
             )
-            if is_pydantic_model:
-                # If the output contains any Pydantic models, we need to initialise them.
-                try:
-                    return convert_cached_output_to_pydantic(
-                        return_type, cached_result.result
-                    )
-                except ValueError as e:
-                    # In case of backward-incompatible pydantic model, just treat it as cache miss, to not error out.
-                    logger.warning(
-                        f"{DB_CACHE_LOG_PREFIX} [cache-miss] Can not validate {cached_result=} into {return_type=} because {e=}, treating as cache miss."
+
+            if cache_none or computed_result is not None:
+                # Save cached result in thread pool (fire-and-forget)
+                asyncio.create_task(
+                    asyncio.to_thread(
+                        _save_cached,
+                        api_keys,
+                        ctx,
+                        computed_result,
+                        log_error_on_unsavable_data,
                     )
-                    cached_result = None
-            else:
-                return cached_result.result
+                )
+
+            return computed_result
+
+        return cast(FunctionT, async_wrapper)
+
+    @wraps(func)
+    def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+        if not api_keys.ENABLE_CACHE:
+            return func(*args, **kwargs)
+
+        _ensure_tables(api_keys)
+
+        ctx = _build_context(func, args, kwargs, ignore_args, ignore_arg_types)
+        lookup = _fetch_cached(api_keys, ctx, max_age)
+
+        if lookup.hit:
+            logger.debug(
+                f"{DB_CACHE_LOG_PREFIX} [cache-hit] Cache hit for {ctx.full_function_name}"
+            )
+            return lookup.value
 
-        # On cache miss, compute the result
         computed_result = func(*args, **kwargs)
-        # Keep the special [case-miss] identifier so we can easily track it in GCP.
-        logger.info(
-            f"{DB_CACHE_LOG_PREFIX} [cache-miss] Cache miss for {full_function_name} with args {args_dict}, computed the output {computed_result}"
+        logger.debug(
+            f"{DB_CACHE_LOG_PREFIX} [cache-miss] Cache miss for {ctx.full_function_name}"
         )
 
-        # If postgres access was specified, save it.
         if cache_none or computed_result is not None:
-            cache_entry = FunctionCache(
-                function_name=function_name,
-                full_function_name=full_function_name,
-                args_hash=args_hash,
-                args=args_dict,
-                result=computed_result,
-                created_at=utcnow(),
-            )
-            # Do not raise an exception if saving to the database fails, just log it and let the agent continue the work.
-            try:
-                with DBManager(
-                    api_keys.sqlalchemy_db_url.get_secret_value()
-                ).get_session() as session:
-                    logger.info(
-                        f"{DB_CACHE_LOG_PREFIX} [cache-info] Saving {cache_entry} into database."
-                    )
-                    session.add(cache_entry)
-                    session.commit()
-            except (DataError, psycopg2.errors.UntranslatableCharacter) as e:
-                (logger.error if log_error_on_unsavable_data else logger.warning)(
-                    f"{DB_CACHE_LOG_PREFIX} [cache-error] Failed to save {cache_entry} into database, ignoring, because: {e}"
-                )
-            except Exception:
-                logger.exception(
-                    f"{DB_CACHE_LOG_PREFIX} [cache-error] Failed to save {cache_entry} into database, ignoring."
-                )
+            _save_cached(api_keys, ctx, computed_result, log_error_on_unsavable_data)
 
         return computed_result
 
-    return cast(FunctionT, wrapper)
+    return cast(FunctionT, sync_wrapper)
+
+
+@dataclass
+class CallContext:
+    args_dict: dict[str, Any]
+    args_hash: str
+    function_name: str
+    full_function_name: str
+    return_type: Any
+
+    @property
+    def is_pydantic_model(self) -> bool:
+        return self.return_type is not None and contains_pydantic_model(
+            self.return_type
+        )
+
+
+@dataclass
+class CacheLookup:
+    hit: bool
+    value: Any | None = None
+
+
+def _ensure_tables(api_keys: APIKeys) -> None:
+    DBManager(api_keys.sqlalchemy_db_url.get_secret_value()).create_tables(
+        [FunctionCache]
+    )
+
+
+def _build_context(
+    func: Callable[..., Any],
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+    ignore_args: Sequence[str] | None,
+    ignore_arg_types: Sequence[type] | None,
+) -> CallContext:
+    signature = inspect.signature(func)
+    bound_arguments = signature.bind(*args, **kwargs)
+    bound_arguments.apply_defaults()
+
+    args_dict: dict[str, Any] = bound_arguments.arguments
+
+    if "self" in args_dict:
+        del args_dict["self"]
+    if "cls" in args_dict:
+        del args_dict["cls"]
+
+    if ignore_args:
+        for arg in ignore_args:
+            if arg in args_dict:
+                del args_dict[arg]
+
+    if ignore_arg_types:
+        args_dict = {
+            k: v
+            for k, v in args_dict.items()
+            if not isinstance(v, tuple(ignore_arg_types))
+        }
+
+    arg_string = json.dumps(args_dict, sort_keys=True, default=str)
+    args_hash = hashlib.md5(arg_string.encode()).hexdigest()
+
+    full_function_name = func.__module__ + "." + func.__qualname__
+    function_name = func.__name__
+
+    # Use get_type_hints to resolve forward references instead of __annotations__
+    try:
+        type_hints = get_type_hints(func)
+        return_type = type_hints.get("return", None)
+    except (NameError, AttributeError, TypeError) as e:
+        # Fallback to raw annotations if get_type_hints fails
+        logger.debug(
+            f"{DB_CACHE_LOG_PREFIX} Failed to resolve type hints for {full_function_name}, falling back to raw annotations: {e}"
+        )
+        return_type = func.__annotations__.get("return", None)
+
+    return CallContext(
+        args_dict=args_dict,
+        args_hash=args_hash,
+        function_name=function_name,
+        full_function_name=full_function_name,
+        return_type=return_type,
+    )
+
+
+def _fetch_cached(
+    api_keys: APIKeys,
+    ctx: CallContext,
+    max_age: timedelta | None,
+) -> CacheLookup:
+    with DBManager(
+        api_keys.sqlalchemy_db_url.get_secret_value()
+    ).get_session() as session:
+        statement = (
+            select(FunctionCache)
+            .where(
+                FunctionCache.function_name == ctx.function_name,
+                FunctionCache.full_function_name == ctx.full_function_name,
+                FunctionCache.args_hash == ctx.args_hash,
+            )
+            .order_by(desc(FunctionCache.created_at))
+        )
+        if max_age is not None:
+            cutoff_time = utcnow() - max_age
+            statement = statement.where(FunctionCache.created_at >= cutoff_time)
+        cached_result = session.exec(statement).first()
+
+    if not cached_result:
+        return CacheLookup(hit=False)
+
+    if ctx.is_pydantic_model:
+        try:
+            value = convert_cached_output_to_pydantic(
+                ctx.return_type, cached_result.result
+            )
+            return CacheLookup(hit=True, value=value)
+        except (ValueError, TypeError) as e:
+            logger.warning(
+                f"{DB_CACHE_LOG_PREFIX} [cache-miss] Failed to validate cached result for {ctx.full_function_name}, treating as cache miss: {e}"
+            )
+            return CacheLookup(hit=False)
+
+    return CacheLookup(hit=True, value=cached_result.result)
+
+
+def _save_cached(
+    api_keys: APIKeys,
+    ctx: CallContext,
+    computed_result: Any,
+    log_error_on_unsavable_data: bool,
+) -> None:
+    cache_entry = FunctionCache(
+        function_name=ctx.function_name,
+        full_function_name=ctx.full_function_name,
+        args_hash=ctx.args_hash,
+        args=ctx.args_dict,
+        result=computed_result,
+        created_at=utcnow(),
+    )
+    try:
+        with DBManager(
+            api_keys.sqlalchemy_db_url.get_secret_value()
+        ).get_session() as session:
+            logger.debug(
+                f"{DB_CACHE_LOG_PREFIX} [cache-save] Saving cache entry for {ctx.full_function_name}"
+            )
+            session.add(cache_entry)
+            session.commit()
+    except (DataError, psycopg2.errors.UntranslatableCharacter) as e:
+        (logger.error if log_error_on_unsavable_data else logger.warning)(
+            f"{DB_CACHE_LOG_PREFIX} [cache-error] Failed to save cache entry for {ctx.full_function_name}: {e}"
+        )
+    except Exception:
+        logger.exception(
+            f"{DB_CACHE_LOG_PREFIX} [cache-error] Failed to save cache entry for {ctx.full_function_name}"
+        )
 
 
 def contains_pydantic_model(return_type: Any) -> bool:

{prediction_market_agent_tooling-0.69.7.dev1114.dist-info → prediction_market_agent_tooling-0.69.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prediction-market-agent-tooling
-Version: 0.69.7.dev1114
+Version: 0.69.9
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 License-File: LICENSE
 Author: Gnosis

{prediction_market_agent_tooling-0.69.7.dev1114.dist-info → prediction_market_agent_tooling-0.69.9.dist-info}/RECORD

@@ -19,6 +19,7 @@ prediction_market_agent_tooling/abis/ownable_erc721.abi.json,sha256=9sxm588MAQmq
 prediction_market_agent_tooling/abis/proxy.abi.json,sha256=h24GXZ6Q0bSZlwh7zOv0EiDvbqUz_PHtWfKHTyPJ1w4,644
 prediction_market_agent_tooling/abis/seer_gnosis_router.abi.json,sha256=DyADzOXhy9MDS31ReVrG7ibpWbw1jVy19nExZ80xfRY,6839
 prediction_market_agent_tooling/abis/seer_market_factory.abi.json,sha256=g7RVxZVUWlTXIgTV2W6kO4twQM909Qv58zAr7Dk4XIc,13553
+prediction_market_agent_tooling/abis/swapr_quoter.abi.json,sha256=pm21GfVFY2yMYn3D0yKYZIYc_GQkX5GfE6lsGv6xl7c,5560
 prediction_market_agent_tooling/abis/swapr_router.abi.json,sha256=Y1wK20D1-zdbdlzkzV0BHY-HXMJrog6dgSHEzKzrQOU,13346
 prediction_market_agent_tooling/benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/benchmark/agents.py,sha256=zC5tUM6pPTWtqSddOOSYV_fxHYmZb5uGAb4Ru87Tah8,4221
@@ -73,22 +74,22 @@ prediction_market_agent_tooling/markets/polymarket/polymarket.py,sha256=QKbmSflc
 prediction_market_agent_tooling/markets/polymarket/polymarket_contracts.py,sha256=x8yvAUPl55nbJALsQAAHJtstahhpH8WcEOj8or_QloQ,1165
 prediction_market_agent_tooling/markets/polymarket/polymarket_subgraph_handler.py,sha256=6_dJbp9YBz0TZW6PxWGIB1L9VE-1JAIzvf8qTBrEyYs,2905
 prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=i1KjkQWABUoQyfX-XBuhACm6-POFMTXWifgP1V2sz-Y,1279
-prediction_market_agent_tooling/markets/seer/data_models.py,sha256=nnuclpajQCkb_s52cCf_rwGWdgjMutaIPyfUq7CqX4M,7626
+prediction_market_agent_tooling/markets/seer/data_models.py,sha256=FjkrI761jXygGMDm9qdoIsCvNaPQc1sGaPcHqIGsjho,8148
 prediction_market_agent_tooling/markets/seer/exceptions.py,sha256=cEObdjluivD94tgOLzmimR7wgQEOt6SRakrYdhsRQtk,112
-prediction_market_agent_tooling/markets/seer/price_manager.py,sha256=Sz8NkbDd5CYruKe6KZ9GU--Jf8FDSkniE-PVrbqGiPM,9952
-prediction_market_agent_tooling/markets/seer/seer.py,sha256=1coDkaHX66s_lWHjzhLEgoaNGeOo87Sxd83e0YGgNDA,31153
+prediction_market_agent_tooling/markets/seer/price_manager.py,sha256=xxApIc4L79vRcF-mmlOK39ZzuBui_H3JkVPgvqwbmj0,11085
+prediction_market_agent_tooling/markets/seer/seer.py,sha256=L5QrpFqfP4jSQOAIZs96S5VEWHrG74Yx2t_Ce0rBWhs,31602
 prediction_market_agent_tooling/markets/seer/seer_api.py,sha256=4iiTWskxWm__oGgUUd1GhV_ItPSrAr0OfnYQ7lKndnQ,1143
-prediction_market_agent_tooling/markets/seer/seer_contracts.py,sha256=LEmZg6PO5GnxI2izxkUYtfU7W58MQJrp8CRoMnF-HSc,6170
+prediction_market_agent_tooling/markets/seer/seer_contracts.py,sha256=0KHxAbUfLu-1cXBr5vBOCkavhKqskmGJBtaCqi5Y1r0,7153
 prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=nmeSofxwtdB6osrP0ASmDWhL684U52Qp4bqJRbRFkCE,18794
 prediction_market_agent_tooling/markets/seer/subgraph_data_models.py,sha256=96v41jdNNxBqTCp5g8SLMSrIgeeITVx5IsBjVgm-qdo,2920
-prediction_market_agent_tooling/markets/seer/swap_pool_handler.py,sha256=k_sCEJZLroVDjOVkZ084VKJGNODLGjBGezhsWEZvlH4,3528
+prediction_market_agent_tooling/markets/seer/swap_pool_handler.py,sha256=24RVIppztXXFkZp0df7GR_GUSslwR42XsPJhDZ-jphs,2612
 prediction_market_agent_tooling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/tools/_generic_value.py,sha256=L9SH_-JwD6RQeKoeTxvNWbkY6CxWIz-VjZEURXoZleg,10617
 prediction_market_agent_tooling/tools/balances.py,sha256=Osab21btfJDw2Y-jT_TV-KHGrseCRxcsYeW6WcOMB8E,1050
 prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py,sha256=o5ba633gKiDqV4t_C2d9FWwH-HkRAOZd8FcZTYvbj6g,14451
 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=MpS3FOMn0C7nbmbQRUT9QwSh3UzzsgGczP91iSMr9wo,261
-prediction_market_agent_tooling/tools/caches/db_cache.py,sha256=rZIGhgijquwwPtp_qncSAPR1SDF2XxIVZL1ir0fgzWw,12127
+prediction_market_agent_tooling/tools/caches/db_cache.py,sha256=V6o6UdesjkKzSJMhqkUtD76cJGPaNhuwA4OL2chIYSI,13801
 prediction_market_agent_tooling/tools/caches/inmemory_cache.py,sha256=ZW5iI5rmjqeAebu5T7ftRnlkxiL02IC-MxCfDB80x7w,1506
 prediction_market_agent_tooling/tools/caches/serializers.py,sha256=vFDx4fsPxclXp2q0sv27j4al_M_Tj9aR2JJP-xNHQXA,2151
 prediction_market_agent_tooling/tools/contract.py,sha256=BzpAFcbKl_KqwgAlaXx63Fg8jzr0EO3qEeOs1K11CPA,33905
@@ -136,8 +137,8 @@ prediction_market_agent_tooling/tools/tokens/usd.py,sha256=DPO-4HBTy1-TZHKL_9CnH
 prediction_market_agent_tooling/tools/transaction_cache.py,sha256=K5YKNL2_tR10Iw2TD9fuP-CTGpBbZtNdgbd0B_R7pjg,1814
 prediction_market_agent_tooling/tools/utils.py,sha256=ruq6P5TFs8CBHxeBLj1Plpx7kuNFPpDgMsJGQgDiRNs,8785
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=CDbaidlLeQ4VHzSg150L7QNfHfGveljSePGuDVFEYqc,13963
-prediction_market_agent_tooling-0.69.7.dev1114.dist-info/METADATA,sha256=n1NsOqe19dtMJ1GoruC0i_INfeuaxR7SgxR5drTGy5Q,8898
-prediction_market_agent_tooling-0.69.7.dev1114.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
-prediction_market_agent_tooling-0.69.7.dev1114.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.69.7.dev1114.dist-info/licenses/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.69.7.dev1114.dist-info/RECORD,,
+prediction_market_agent_tooling-0.69.9.dist-info/METADATA,sha256=fBezbmaBxLVzpMNtCsmCnE2Pc8ywbXJTnCRF7HMJcYw,8890
+prediction_market_agent_tooling-0.69.9.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
+prediction_market_agent_tooling-0.69.9.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.69.9.dist-info/licenses/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.69.9.dist-info/RECORD,,