prediction-market-agent-tooling 0.56.0.dev1863__py3-none-any.whl → 0.56.2.dev129__py3-none-any.whl

prediction_market_agent_tooling/config.py

@@ -53,7 +53,7 @@ class APIKeys(BaseSettings):
 
     SQLALCHEMY_DB_URL: t.Optional[SecretStr] = None
 
-    ENABLE_CACHE: bool = True
+    ENABLE_CACHE: bool = False
     CACHE_DIR: str = "./.cache"
 
     @property

prediction_market_agent_tooling/deploy/agent.py

@@ -153,10 +153,10 @@ class DeployableAgent:
             input=input,
             output=output,
             user_id=user_id or getpass.getuser(),
-            session_id=session_id
-            or self.session_id,  # All traces within a single run execution will be grouped under a single session.
-            version=version
-            or APIKeys().LANGFUSE_DEPLOYMENT_VERSION,  # Optionally, mark the current deployment with version (e.g. add git commit hash during docker building).
+            session_id=session_id or self.session_id,
+            # All traces within a single run execution will be grouped under a single session.
+            version=version or APIKeys().LANGFUSE_DEPLOYMENT_VERSION,
+            # Optionally, mark the current deployment with version (e.g. add git commit hash during docker building).
             release=release,
             metadata=metadata,
             tags=tags,
@@ -342,6 +342,10 @@ class DeployablePredictionAgent(DeployableAgent):
             ]
         )
 
+    @property
+    def agent_name(self) -> str:
+        return self.__class__.__name__
+
     def check_min_required_balance_to_operate(self, market_type: MarketType) -> None:
         api_keys = APIKeys()
 
@@ -444,7 +448,9 @@ class DeployablePredictionAgent(DeployableAgent):
     ) -> None:
         keys = APIKeys()
         if self.store_prediction:
-            market.store_prediction(processed_market=processed_market, keys=keys)
+            market.store_prediction(
+                processed_market=processed_market, keys=keys, agent_name=self.agent_name
+            )
         else:
             logger.info(
                 f"Prediction {processed_market} not stored because {self.store_prediction=}."
@@ -519,7 +525,6 @@ class DeployableTraderAgent(DeployablePredictionAgent):
     def initialize_langfuse(self) -> None:
         super().initialize_langfuse()
         # Auto-observe all the methods where it makes sense, so that subclassses don't need to do it manually.
-        self.get_betting_strategy = observe()(self.get_betting_strategy)  # type: ignore[method-assign]
         self.build_trades = observe()(self.build_trades)  # type: ignore[method-assign]
 
     def check_min_required_balance_to_trade(self, market: AgentMarket) -> None:
@@ -555,16 +560,18 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         BettingStrategy.assert_trades_currency_match_markets(market, trades)
         return trades
 
+    def before_process_market(
+        self, market_type: MarketType, market: AgentMarket
+    ) -> None:
+        super().before_process_market(market_type, market)
+        self.check_min_required_balance_to_trade(market)
+
     def process_market(
         self,
         market_type: MarketType,
         market: AgentMarket,
         verify_market: bool = True,
     ) -> ProcessedTradedMarket | None:
-        self.check_min_required_balance_to_trade(
-            market
-        )  # Do this as part of `process_market` because it observes some methods --> To keep everything traced under the `process_market`.
-
         processed_market = super().process_market(market_type, market, verify_market)
         if processed_market is None:
             return None
@@ -612,10 +619,14 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         processed_market: ProcessedMarket | None,
     ) -> None:
         api_keys = APIKeys()
-        super().after_process_market(market_type, market, processed_market)
+        super().after_process_market(
+            market_type,
+            market,
+            processed_market,
+        )
         if isinstance(processed_market, ProcessedTradedMarket):
             if self.store_trades:
-                market.store_trades(processed_market, api_keys)
+                market.store_trades(processed_market, api_keys, self.agent_name)
             else:
                 logger.info(
                     f"Trades {processed_market.trades} not stored because {self.store_trades=}."

prediction_market_agent_tooling/jobs/jobs_models.py

@@ -3,7 +3,12 @@ from abc import ABC, abstractmethod
 
 from pydantic import BaseModel
 
-from prediction_market_agent_tooling.markets.agent_market import AgentMarket
+from prediction_market_agent_tooling.deploy.betting_strategy import ProbabilisticAnswer
+from prediction_market_agent_tooling.gtypes import Probability
+from prediction_market_agent_tooling.markets.agent_market import (
+    AgentMarket,
+    ProcessedTradedMarket,
+)
 from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
     FilterBy,
     SortBy,
@@ -39,10 +44,24 @@ class JobAgentMarket(AgentMarket, ABC):
     @classmethod
     @abstractmethod
     def get_jobs(
-        cls, limit: int | None, filter_by: FilterBy, sort_by: SortBy
+        cls,
+        limit: int | None,
+        filter_by: FilterBy = FilterBy.OPEN,
+        sort_by: SortBy = SortBy.CLOSING_SOONEST,
     ) -> t.Sequence["JobAgentMarket"]:
         """Get all available jobs."""
 
+    @staticmethod
+    @abstractmethod
+    def get_job(id: str) -> "JobAgentMarket":
+        """Get a single job by its id."""
+
+    @abstractmethod
+    def submit_job_result(
+        self, agent_name: str, max_bond: float, result: str
+    ) -> ProcessedTradedMarket:
+        """Submit the completed result for this job."""
+
     def to_simple_job(self, max_bond: float) -> SimpleJob:
         return SimpleJob(
             id=self.id,
@@ -51,3 +70,9 @@ class JobAgentMarket(AgentMarket, ABC):
             currency=self.currency.value,
             deadline=self.deadline,
         )
+
+    def get_job_answer(self, result: str) -> ProbabilisticAnswer:
+        # Just return 100% yes with 100% confidence, because we assume the job is completed correctly.
+        return ProbabilisticAnswer(
+            p_yes=Probability(1.0), confidence=1.0, reasoning=result
+        )

prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -1,15 +1,14 @@
 import typing as t
 
-from web3 import Web3
-
+from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.betting_strategy import (
     Currency,
     KellyBettingStrategy,
-    ProbabilisticAnswer,
     TradeType,
 )
-from prediction_market_agent_tooling.gtypes import Probability
 from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
+from prediction_market_agent_tooling.markets.agent_market import ProcessedTradedMarket
+from prediction_market_agent_tooling.markets.data_models import PlacedTrade, Trade
 from prediction_market_agent_tooling.markets.omen.omen import (
     BetAmount,
     OmenAgentMarket,
@@ -36,11 +35,27 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
         return self.close_time
 
     def get_reward(self, max_bond: float) -> float:
-        return compute_job_reward(self, max_bond)
+        trade = self.get_job_trade(
+            max_bond,
+            result="",  # Pass empty result, as we are computing only potential reward at this point.
+        )
+        reward = (
+            self.get_buy_token_amount(
+                bet_amount=BetAmount(
+                    amount=trade.amount.amount, currency=trade.amount.currency
+                ),
+                direction=trade.outcome,
+            ).amount
+            - trade.amount.amount
+        )
+        return reward
 
     @classmethod
     def get_jobs(
-        cls, limit: int | None, filter_by: FilterBy, sort_by: SortBy
+        cls,
+        limit: int | None,
+        filter_by: FilterBy = FilterBy.OPEN,
+        sort_by: SortBy = SortBy.CLOSING_SOONEST,
     ) -> t.Sequence["OmenJobAgentMarket"]:
         markets = OmenSubgraphHandler().get_omen_binary_markets_simple(
             limit=limit,
@@ -50,6 +65,52 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
         )
         return [OmenJobAgentMarket.from_omen_market(market) for market in markets]
 
+    @staticmethod
+    def get_job(id: str) -> "OmenJobAgentMarket":
+        return OmenJobAgentMarket.from_omen_agent_market(
+            OmenJobAgentMarket.get_binary_market(id=id)
+        )
+
+    def submit_job_result(
+        self, agent_name: str, max_bond: float, result: str
+    ) -> ProcessedTradedMarket:
+        if not APIKeys().enable_ipfs_upload:
+            raise RuntimeError(
+                f"ENABLE_IPFS_UPLOAD must be set to True to upload job results."
+            )
+
+        trade = self.get_job_trade(max_bond, result)
+        buy_id = self.buy_tokens(outcome=trade.outcome, amount=trade.amount)
+
+        processed_traded_market = ProcessedTradedMarket(
+            answer=self.get_job_answer(result),
+            trades=[PlacedTrade.from_trade(trade, id=buy_id)],
+        )
+
+        keys = APIKeys()
+        self.store_trades(processed_traded_market, keys, agent_name)
+
+        return processed_traded_market
+
+    def get_job_trade(self, max_bond: float, 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)
+        required_trades = strategy.calculate_trades(
+            existing_position=None,
+            answer=self.get_job_answer(result),
+            market=self,
+        )
+        assert (
+            len(required_trades) == 1
+        ), f"Shouldn't process same job twice: {required_trades}"
+        trade = required_trades[0]
+        assert trade.trade_type == TradeType.BUY, "Should only buy on job markets."
+        assert trade.outcome, "Should buy only YES on job markets."
+        assert (
+            trade.amount.currency == Currency.xDai
+        ), "Should work only on real-money markets."
+        return required_trades[0]
+
     @staticmethod
     def from_omen_market(market: OmenMarket) -> "OmenJobAgentMarket":
         return OmenJobAgentMarket.from_omen_agent_market(
@@ -77,38 +138,3 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
             finalized_time=market.finalized_time,
             fees=market.fees,
         )
-
-
-def compute_job_reward(
-    market: OmenAgentMarket, max_bond: float, web3: Web3 | None = None
-) -> float:
-    # 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)
-    required_trades = strategy.calculate_trades(
-        existing_position=None,
-        # We assume that we finish the job and so the probability of the market happening will be 100%.
-        answer=ProbabilisticAnswer(p_yes=Probability(1.0), confidence=1.0),
-        market=market,
-    )
-
-    assert (
-        len(required_trades) == 1
-    ), f"Shouldn't process same job twice: {required_trades}"
-    trade = required_trades[0]
-    assert trade.trade_type == TradeType.BUY, "Should only buy on job markets."
-    assert trade.outcome, "Should buy only YES on job markets."
-    assert (
-        trade.amount.currency == Currency.xDai
-    ), "Should work only on real-money markets."
-
-    reward = (
-        market.get_buy_token_amount(
-            bet_amount=BetAmount(
-                amount=trade.amount.amount, currency=trade.amount.currency
-            ),
-            direction=trade.outcome,
-        ).amount
-        - trade.amount.amount
-    )
-
-    return reward

prediction_market_agent_tooling/markets/agent_market.py

@@ -231,7 +231,10 @@ class AgentMarket(BaseModel):
         raise NotImplementedError("Subclasses must implement this method")
 
     def store_prediction(
-        self, processed_market: ProcessedMarket | None, keys: APIKeys
+        self,
+        processed_market: ProcessedMarket | None,
+        keys: APIKeys,
+        agent_name: str,
     ) -> None:
         """
         If market allows to upload predictions somewhere, implement it in this method.
@@ -239,7 +242,10 @@ class AgentMarket(BaseModel):
         raise NotImplementedError("Subclasses must implement this method")
 
     def store_trades(
-        self, traded_market: ProcessedTradedMarket | None, keys: APIKeys
+        self,
+        traded_market: ProcessedTradedMarket | None,
+        keys: APIKeys,
+        agent_name: str,
     ) -> None:
         """
         If market allows to upload trades somewhere, implement it in this method.

prediction_market_agent_tooling/markets/base_subgraph_handler.py

@@ -0,0 +1,51 @@
+import typing as t
+
+import tenacity
+from pydantic import BaseModel
+from subgrounds import FieldPath, Subgrounds
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.tools.singleton import SingletonMeta
+
+T = t.TypeVar("T", bound=BaseModel)
+
+
+class BaseSubgraphHandler(metaclass=SingletonMeta):
+    def __init__(self) -> None:
+        self.sg = Subgrounds()
+        # Patch methods to retry on failure.
+        self.sg.query_json = tenacity.retry(
+            stop=tenacity.stop_after_attempt(3),
+            wait=tenacity.wait_fixed(1),
+            after=lambda x: logger.debug(f"query_json failed, {x.attempt_number=}."),
+        )(self.sg.query_json)
+        self.sg.load_subgraph = tenacity.retry(
+            stop=tenacity.stop_after_attempt(3),
+            wait=tenacity.wait_fixed(1),
+            after=lambda x: logger.debug(f"load_subgraph failed, {x.attempt_number=}."),
+        )(self.sg.load_subgraph)
+
+        self.keys = APIKeys()
+
+    def _parse_items_from_json(
+        self, result: list[dict[str, t.Any]]
+    ) -> list[dict[str, t.Any]]:
+        """subgrounds return a weird key as a dict key"""
+        items = []
+        for result_chunk in result:
+            for k, v in result_chunk.items():
+                # subgrounds might pack all items as a list, indexed by a key, or pack it as a dictionary (if one single element)
+                if v is None:
+                    continue
+                elif isinstance(v, dict):
+                    items.extend([v])
+                else:
+                    items.extend(v)
+        return items
+
+    def do_query(self, fields: list[FieldPath], pydantic_model: t.Type[T]) -> list[T]:
+        result = self.sg.query_json(fields)
+        items = self._parse_items_from_json(result)
+        models = [pydantic_model.model_validate(i) for i in items]
+        return models

prediction_market_agent_tooling/markets/markets.py

@@ -3,6 +3,8 @@ from datetime import timedelta
 from enum import Enum
 
 from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
+from prediction_market_agent_tooling.jobs.omen.omen_jobs import OmenJobAgentMarket
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
@@ -46,6 +48,12 @@ class MarketType(str, Enum):
             raise ValueError(f"Unknown market type: {self}")
         return MARKET_TYPE_TO_AGENT_MARKET[self]
 
+    @property
+    def job_class(self) -> type[JobAgentMarket]:
+        if self not in JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET:
+            raise ValueError(f"Unknown market type: {self}")
+        return JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET[self]
+
     @property
     def is_blockchain_market(self) -> bool:
         return self in [MarketType.OMEN, MarketType.POLYMARKET]
@@ -58,6 +66,10 @@ MARKET_TYPE_TO_AGENT_MARKET: dict[MarketType, type[AgentMarket]] = {
     MarketType.METACULUS: MetaculusAgentMarket,
 }
 
+JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET: dict[MarketType, type[JobAgentMarket]] = {
+    MarketType.OMEN: OmenJobAgentMarket,
+}
+
 
 def get_binary_markets(
     limit: int,

prediction_market_agent_tooling/markets/metaculus/metaculus.py

@@ -107,7 +107,7 @@ class MetaculusAgentMarket(AgentMarket):
         return [MetaculusAgentMarket.from_data_model(q) for q in all_questions[:limit]]
 
     def store_prediction(
-        self, processed_market: ProcessedMarket | None, keys: APIKeys
+        self, processed_market: ProcessedMarket | None, keys: APIKeys, agent_name: str
     ) -> None:
         if processed_market is not None:
             make_prediction(self.id, processed_market.answer.p_yes)

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -24,6 +24,7 @@ from prediction_market_agent_tooling.markets.data_models import (
     ResolvedBet,
 )
 from prediction_market_agent_tooling.tools.utils import (
+    BPS_CONSTANT,
     DatetimeUTC,
     check_not_none,
     should_not_happen,
@@ -502,7 +503,7 @@ class OmenBet(BaseModel):
     feeAmount: Wei
     outcomeIndex: int
     outcomeTokensTraded: Wei
-    transactionHash: HexAddress
+    transactionHash: HexBytes
     fpmm: OmenMarket
 
     @property
@@ -785,6 +786,14 @@ class ContractPrediction(BaseModel):
     tx_hashes: list[HexBytes] = Field(..., alias="txHashes")
     estimated_probability_bps: int = Field(..., alias="estimatedProbabilityBps")
 
+    @property
+    def estimated_probability(self) -> Probability:
+        return Probability(self.estimated_probability_bps / BPS_CONSTANT)
+
+    @property
+    def boolean_outcome(self) -> bool:
+        return self.estimated_probability > 0.5
+
     @computed_field  # type: ignore[prop-decorator] # Mypy issue: https://github.com/python/mypy/issues/14461
     @property
     def publisher_checksummed(self) -> ChecksumAddress:
@@ -798,7 +807,7 @@ class ContractPrediction(BaseModel):
 
 class IPFSAgentResult(BaseModel):
     reasoning: str
-
+    agent_name: str
     model_config = ConfigDict(
         extra="forbid",
     )

prediction_market_agent_tooling/markets/omen/omen.py

@@ -78,6 +78,7 @@ from prediction_market_agent_tooling.tools.contract import (
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
 from prediction_market_agent_tooling.tools.ipfs.ipfs_handler import IPFSHandler
 from prediction_market_agent_tooling.tools.utils import (
+    BPS_CONSTANT,
     DatetimeUTC,
     calculate_sell_amount_in_collateral,
     check_not_none,
@@ -413,17 +414,21 @@ class OmenAgentMarket(AgentMarket):
     @staticmethod
     def verify_operational_balance(api_keys: APIKeys) -> bool:
         return get_total_balance(
-            api_keys.public_key,  # Use `public_key`, not `bet_from_address` because transaction costs are paid from the EOA wallet.
+            api_keys.public_key,
+            # Use `public_key`, not `bet_from_address` because transaction costs are paid from the EOA wallet.
             sum_wxdai=False,
         ) > xdai_type(0.001)
 
     def store_prediction(
-        self, processed_market: ProcessedMarket | None, keys: APIKeys
+        self, processed_market: ProcessedMarket | None, keys: APIKeys, agent_name: str
     ) -> None:
         """On Omen, we have to store predictions along with trades, see `store_trades`."""
 
     def store_trades(
-        self, traded_market: ProcessedTradedMarket | None, keys: APIKeys
+        self,
+        traded_market: ProcessedTradedMarket | None,
+        keys: APIKeys,
+        agent_name: str,
     ) -> None:
         if traded_market is None:
             logger.warning(f"No prediction for market {self.id}, not storing anything.")
@@ -437,7 +442,7 @@ class OmenAgentMarket(AgentMarket):
         if keys.enable_ipfs_upload:
             logger.info("Storing prediction on IPFS.")
             ipfs_hash = IPFSHandler(keys).store_agent_result(
-                IPFSAgentResult(reasoning=reasoning)
+                IPFSAgentResult(reasoning=reasoning, agent_name=agent_name)
             )
             ipfs_hash_decoded = ipfscidv0_to_byte32(ipfs_hash)
 
@@ -448,7 +453,7 @@ class OmenAgentMarket(AgentMarket):
             publisher=keys.public_key,
             ipfs_hash=ipfs_hash_decoded,
             tx_hashes=tx_hashes,
-            estimated_probability_bps=int(traded_market.answer.p_yes * 10000),
+            estimated_probability_bps=int(traded_market.answer.p_yes * BPS_CONSTANT),
         )
         tx_receipt = OmenAgentResultMappingContract().add_prediction(
             api_keys=keys,
@@ -1237,12 +1242,12 @@ def redeem_from_all_user_positions(
 
         if not conditional_token_contract.is_condition_resolved(condition_id):
             logger.info(
-                f"[{index+1} / {len(user_positions)}] Skipping redeem, {user_position.id=} isn't resolved yet."
+                f"[{index + 1} / {len(user_positions)}] Skipping redeem, {user_position.id=} isn't resolved yet."
             )
             continue
 
         logger.info(
-            f"[{index+1} / {len(user_positions)}] Processing redeem from {user_position.id=}."
+            f"[{index + 1} / {len(user_positions)}] Processing redeem from {user_position.id=}."
         )
 
         original_balances = get_balances(public_key, web3)
@@ -1263,9 +1268,11 @@ def redeem_from_all_user_positions(
 def get_binary_market_p_yes_history(market: OmenAgentMarket) -> list[Probability]:
     history: list[Probability] = []
     trades = sorted(
-        OmenSubgraphHandler().get_trades(  # We need to look at price both after buying or selling, so get trades, not bets.
+        OmenSubgraphHandler().get_trades(
+            # We need to look at price both after buying or selling, so get trades, not bets.
             market_id=market.market_maker_contract_address_checksummed,
-            end_time=market.close_time,  # Even after market is closed, there can be many `Sell` trades which will converge the probability to the true one.
+            end_time=market.close_time,
+            # Even after market is closed, there can be many `Sell` trades which will converge the probability to the true one.
         ),
         key=lambda x: x.creation_datetime,
     )

prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -2,12 +2,10 @@ import sys
 import typing as t
 
 import requests
-import tenacity
 from PIL import Image
 from PIL.Image import Image as ImageType
-from subgrounds import FieldPath, Subgrounds
+from subgrounds import FieldPath
 
-from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
     HexAddress,
@@ -15,8 +13,10 @@ from prediction_market_agent_tooling.gtypes import (
     Wei,
     wei_type,
 )
-from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import FilterBy, SortBy
+from prediction_market_agent_tooling.markets.base_subgraph_handler import (
+    BaseSubgraphHandler,
+)
 from prediction_market_agent_tooling.markets.omen.data_models import (
     OMEN_BINARY_MARKET_OUTCOMES,
     ContractPrediction,
@@ -33,7 +33,6 @@ from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     WrappedxDaiContract,
     sDaiContract,
 )
-from prediction_market_agent_tooling.tools.singleton import SingletonMeta
 from prediction_market_agent_tooling.tools.utils import (
     DatetimeUTC,
     to_int_timestamp,
@@ -51,7 +50,7 @@ SAFE_COLLATERAL_TOKEN_MARKETS = (
 )
 
 
-class OmenSubgraphHandler(metaclass=SingletonMeta):
+class OmenSubgraphHandler(BaseSubgraphHandler):
     """
     Class responsible for handling interactions with Omen subgraphs (trades, conditionalTokens).
     """
@@ -64,52 +63,38 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
 
     OMEN_IMAGE_MAPPING_GRAPH_URL = "https://gateway-arbitrum.network.thegraph.com/api/{graph_api_key}/subgraphs/id/EWN14ciGK53PpUiKSm7kMWQ6G4iz3tDrRLyZ1iXMQEdu"
 
-    OMEN_AGENT_RESULT_MAPPING_GRAPH_URL = "https://gateway-arbitrum.network.thegraph.com/api/{graph_api_key}/subgraphs/id/GoE3UFyc8Gg9xzv92oinonyhRCphpGu62qB2Eh2XvJ8F"
+    OMEN_AGENT_RESULT_MAPPING_GRAPH_URL = "https://gateway-arbitrum.network.thegraph.com/api/{graph_api_key}/subgraphs/id/J6bJEnbqJpAvNyQE8i58M9mKF4zqo33BEJRdnXmqa6Kn"
 
     INVALID_ANSWER = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
 
     def __init__(self) -> None:
-        self.sg = Subgrounds()
-
-        # Patch methods to retry on failure.
-        self.sg.query_json = tenacity.retry(
-            stop=tenacity.stop_after_attempt(3),
-            wait=tenacity.wait_fixed(1),
-            after=lambda x: logger.debug(f"query_json failed, {x.attempt_number=}."),
-        )(self.sg.query_json)
-        self.sg.load_subgraph = tenacity.retry(
-            stop=tenacity.stop_after_attempt(3),
-            wait=tenacity.wait_fixed(1),
-            after=lambda x: logger.debug(f"load_subgraph failed, {x.attempt_number=}."),
-        )(self.sg.load_subgraph)
-
-        keys = APIKeys()
+        super().__init__()
 
         # Load the subgraph
         self.trades_subgraph = self.sg.load_subgraph(
             self.OMEN_TRADES_SUBGRAPH.format(
-                graph_api_key=keys.graph_api_key.get_secret_value()
+                graph_api_key=self.keys.graph_api_key.get_secret_value()
             )
         )
         self.conditional_tokens_subgraph = self.sg.load_subgraph(
             self.CONDITIONAL_TOKENS_SUBGRAPH.format(
-                graph_api_key=keys.graph_api_key.get_secret_value()
+                graph_api_key=self.keys.graph_api_key.get_secret_value()
             )
         )
         self.realityeth_subgraph = self.sg.load_subgraph(
             self.REALITYETH_GRAPH_URL.format(
-                graph_api_key=keys.graph_api_key.get_secret_value()
+                graph_api_key=self.keys.graph_api_key.get_secret_value()
             )
         )
         self.omen_image_mapping_subgraph = self.sg.load_subgraph(
             self.OMEN_IMAGE_MAPPING_GRAPH_URL.format(
-                graph_api_key=keys.graph_api_key.get_secret_value()
+                graph_api_key=self.keys.graph_api_key.get_secret_value()
             )
         )
 
         self.omen_agent_result_mapping_subgraph = self.sg.load_subgraph(
             self.OMEN_AGENT_RESULT_MAPPING_GRAPH_URL.format(
-                graph_api_key=keys.graph_api_key.get_secret_value()
+                graph_api_key=self.keys.graph_api_key.get_secret_value()
             )
         )
 
@@ -446,14 +431,8 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
             **optional_params,
         )
 
-        omen_markets = self.do_markets_query(markets)
-        return omen_markets
-
-    def do_markets_query(self, markets: FieldPath) -> list[OmenMarket]:
         fields = self._get_fields_for_markets(markets)
-        result = self.sg.query_json(fields)
-        items = self._parse_items_from_json(result)
-        omen_markets = [OmenMarket.model_validate(i) for i in items]
+        omen_markets = self.do_query(fields=fields, pydantic_model=OmenMarket)
         return omen_markets
 
     def get_omen_market_by_market_id(self, market_id: HexAddress) -> OmenMarket:
@@ -461,7 +440,8 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
             id=market_id.lower()
         )
 
-        omen_markets = self.do_markets_query(markets)
+        fields = self._get_fields_for_markets(markets)
+        omen_markets = self.do_query(fields=fields, pydantic_model=OmenMarket)
 
         if len(omen_markets) != 1:
             raise ValueError(
@@ -470,22 +450,6 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
 
         return omen_markets[0]
 
-    def _parse_items_from_json(
-        self, result: list[dict[str, t.Any]]
-    ) -> list[dict[str, t.Any]]:
-        """subgrounds return a weird key as a dict key"""
-        items = []
-        for result_chunk in result:
-            for k, v in result_chunk.items():
-                # subgrounds might pack all items as a list, indexed by a key, or pack it as a dictionary (if one single element)
-                if v is None:
-                    continue
-                elif isinstance(v, dict):
-                    items.extend([v])
-                else:
-                    items.extend(v)
-        return items
-
     def _get_fields_for_user_positions(
         self, user_positions: FieldPath
     ) -> list[FieldPath]:
@@ -944,3 +908,17 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         if not items:
             return []
         return [ContractPrediction.model_validate(i) for i in items]
+
+    def get_agent_results_for_bet(self, bet: OmenBet) -> ContractPrediction | None:
+        results = [
+            result
+            for result in self.get_agent_results_for_market(bet.fpmm.id)
+            if bet.transactionHash in result.tx_hashes
+        ]
+
+        if not results:
+            return None
+        elif len(results) > 1:
+            raise RuntimeError("Multiple results found for a single bet.")
+
+        return results[0]

prediction_market_agent_tooling/markets/seer/data_models.py

@@ -0,0 +1,27 @@
+from pydantic import BaseModel, ConfigDict, Field
+
+from prediction_market_agent_tooling.gtypes import HexBytes
+
+
+class SeerMarket(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: HexBytes
+    title: str = Field(alias="marketName")
+    outcomes: list[str]
+    parent_market: HexBytes = Field(alias="parentMarket")
+    wrapped_tokens: list[HexBytes] = Field(alias="wrappedTokens")
+
+
+class SeerToken(BaseModel):
+    id: HexBytes
+    name: str
+    symbol: str
+
+
+class SeerPool(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    id: HexBytes
+    liquidity: int
+    token0: SeerToken
+    token1: SeerToken

prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py

@@ -0,0 +1,142 @@
+from typing import Any
+
+from subgrounds import FieldPath
+from web3.constants import ADDRESS_ZERO
+
+from prediction_market_agent_tooling.markets.base_subgraph_handler import (
+    BaseSubgraphHandler,
+)
+from prediction_market_agent_tooling.markets.seer.data_models import (
+    SeerMarket,
+    SeerPool,
+)
+from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
+
+INVALID_OUTCOME = "Invalid result"
+
+
+class SeerSubgraphHandler(BaseSubgraphHandler):
+    """
+    Class responsible for handling interactions with Seer subgraphs.
+    """
+
+    SEER_SUBGRAPH = "https://gateway-arbitrum.network.thegraph.com/api/{graph_api_key}/subgraphs/id/B4vyRqJaSHD8dRDb3BFRoAzuBK18c1QQcXq94JbxDxWH"
+
+    SWAPR_ALGEBRA_SUBGRAPH = "https://gateway-arbitrum.network.thegraph.com/api/{graph_api_key}/subgraphs/id/AAA1vYjxwFHzbt6qKwLHNcDSASyr1J1xVViDH8gTMFMR"
+
+    INVALID_ANSWER = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.seer_subgraph = self.sg.load_subgraph(
+            self.SEER_SUBGRAPH.format(
+                graph_api_key=self.keys.graph_api_key.get_secret_value()
+            )
+        )
+        self.swapr_algebra_subgraph = self.sg.load_subgraph(
+            self.SWAPR_ALGEBRA_SUBGRAPH.format(
+                graph_api_key=self.keys.graph_api_key.get_secret_value()
+            )
+        )
+
+    def _get_fields_for_markets(self, markets_field: FieldPath) -> list[FieldPath]:
+        fields = [
+            markets_field.id,
+            markets_field.factory,
+            markets_field.creator,
+            markets_field.marketName,
+            markets_field.outcomes,
+            markets_field.parentMarket,
+            markets_field.finalizeTs,
+            markets_field.wrappedTokens,
+        ]
+        return fields
+
+    @staticmethod
+    def filter_bicategorical_markets(markets: list[SeerMarket]) -> list[SeerMarket]:
+        # We do an extra check for the invalid outcome for safety.
+        return [
+            m for m in markets if len(m.outcomes) == 3 and INVALID_OUTCOME in m.outcomes
+        ]
+
+    @staticmethod
+    def filter_binary_markets(markets: list[SeerMarket]) -> list[SeerMarket]:
+        return [
+            market
+            for market in markets
+            if {"yes", "no"}.issubset({o.lower() for o in market.outcomes})
+        ]
+
+    @staticmethod
+    def build_filter_for_conditional_markets(
+        include_conditional_markets: bool = True,
+    ) -> dict[Any, Any]:
+        return (
+            {}
+            if include_conditional_markets
+            else {"parentMarket": ADDRESS_ZERO.lower()}
+        )
+
+    def get_bicategorical_markets(
+        self, include_conditional_markets: bool = True
+    ) -> list[SeerMarket]:
+        """Returns markets that contain 2 categories plus an invalid outcome."""
+        # Binary markets on Seer contain 3 outcomes: OutcomeA, outcomeB and an Invalid option.
+        query_filter = self.build_filter_for_conditional_markets(
+            include_conditional_markets
+        )
+        query_filter["outcomes_contains"] = [INVALID_OUTCOME]
+        markets_field = self.seer_subgraph.Query.markets(where=query_filter)
+        fields = self._get_fields_for_markets(markets_field)
+        markets = self.do_query(fields=fields, pydantic_model=SeerMarket)
+        two_category_markets = self.filter_bicategorical_markets(markets)
+        return two_category_markets
+
+    def get_binary_markets(
+        self, include_conditional_markets: bool = True
+    ) -> list[SeerMarket]:
+        two_category_markets = self.get_bicategorical_markets(
+            include_conditional_markets=include_conditional_markets
+        )
+        # Now we additionally filter markets based on YES/NO being the only outcomes.
+        binary_markets = self.filter_binary_markets(two_category_markets)
+        return binary_markets
+
+    def get_market_by_id(self, market_id: HexBytes) -> SeerMarket:
+        markets_field = self.seer_subgraph.Query.market(id=market_id.hex().lower())
+        fields = self._get_fields_for_markets(markets_field)
+        markets = self.do_query(fields=fields, pydantic_model=SeerMarket)
+        if len(markets) != 1:
+            raise ValueError(
+                f"Fetched wrong number of markets. Expected 1 but got {len(markets)}"
+            )
+        return markets[0]
+
+    def _get_fields_for_pools(self, pools_field: FieldPath) -> list[FieldPath]:
+        fields = [
+            pools_field.id,
+            pools_field.liquidity,
+            pools_field.token0.id,
+            pools_field.token0.name,
+            pools_field.token0.symbol,
+            pools_field.token1.id,
+            pools_field.token1.name,
+            pools_field.token1.symbol,
+        ]
+        return fields
+
+    def get_pools_for_market(self, market: SeerMarket) -> list[SeerPool]:
+        # We iterate through the wrapped tokens and put them in a where clause so that we hit the subgraph endpoint just once.
+        wheres = []
+        for wrapped_token in market.wrapped_tokens:
+            wheres.extend(
+                [
+                    {"token0": wrapped_token.hex().lower()},
+                    {"token1": wrapped_token.hex().lower()},
+                ]
+            )
+        pools_field = self.swapr_algebra_subgraph.Query.pools(where={"or": wheres})
+        fields = self._get_fields_for_pools(pools_field)
+        pools = self.do_query(fields=fields, pydantic_model=SeerPool)
+        return pools

prediction_market_agent_tooling/tools/caches/db_cache.py

@@ -15,7 +15,7 @@ from typing import (
 )
 
 from pydantic import BaseModel
-from sqlalchemy import Column
+from sqlalchemy import Column, Engine
 from sqlalchemy.dialects.postgresql import JSONB
 from sqlmodel import Field, Session, SQLModel, create_engine, desc, select
 
@@ -40,6 +40,9 @@ class FunctionCache(SQLModel, table=True):
     created_at: DatetimeUTC = Field(default_factory=utcnow, index=True)
 
 
+DB_CACHE_ENGINE: None | Engine = None
+
+
 @overload
 def db_cache(
     func: None = None,
@@ -91,40 +94,30 @@ def db_cache(
 
     api_keys = api_keys if api_keys is not None else APIKeys()
 
-    sqlalchemy_db_url = api_keys.SQLALCHEMY_DB_URL
-    if sqlalchemy_db_url is None:
-        logger.warning(
-            f"SQLALCHEMY_DB_URL not provided in the environment, skipping function caching."
-        )
-
-    engine = (
-        create_engine(
-            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,
-        )
-        if sqlalchemy_db_url is not None
-        else None
-    )
-
-    # Create table if it doesn't exist
-    if engine is not None:
-        SQLModel.metadata.create_all(engine)
-
     @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)
 
+        global DB_CACHE_ENGINE
+        if DB_CACHE_ENGINE is None:
+            DB_CACHE_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,
+            )
+            # Create table if it doesn't exist
+            SQLModel.metadata.create_all(DB_CACHE_ENGINE)
+
         # 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 = convert_pydantic_to_dict(bound_arguments.arguments)
+        args_dict: dict[str, Any] = bound_arguments.arguments
 
         # Remove `self` or `cls` if present (in case of class' methods)
         if "self" in args_dict:
@@ -162,25 +155,21 @@ def db_cache(
         if return_type is not None and contains_pydantic_model(return_type):
             is_pydantic_model = True
 
-        # If postgres access was specified, try to find a hit
-        if engine is not None:
-            with Session(engine) 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,
-                    )
-                    .order_by(desc(FunctionCache.created_at))
+        with Session(DB_CACHE_ENGINE) 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 max_age is not None:
-                    cutoff_time = utcnow() - max_age
-                    statement = statement.where(FunctionCache.created_at >= cutoff_time)
-                cached_result = session.exec(statement).first()
-        else:
-            cached_result = None
+                .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(
@@ -210,22 +199,16 @@ def db_cache(
         )
 
         # If postgres access was specified, save it.
-        if engine is not None and (cache_none or computed_result is not None):
-            # In case of Pydantic outputs, we need to dictionarize it for it to be serializable.
-            result_data = (
-                convert_pydantic_to_dict(computed_result)
-                if is_pydantic_model
-                else computed_result
-            )
+        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=result_data,
+                result=computed_result,
                 created_at=utcnow(),
             )
-            with Session(engine) as session:
+            with Session(DB_CACHE_ENGINE) as session:
                 logger.info(f"Saving {cache_entry} into database.")
                 session.add(cache_entry)
                 session.commit()
@@ -249,9 +232,12 @@ def contains_pydantic_model(return_type: Any) -> bool:
     return False
 
 
-def json_serializer_default_fn(y: DatetimeUTC | timedelta | date) -> str:
+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):
@@ -260,6 +246,8 @@ def json_serializer_default_fn(y: DatetimeUTC | timedelta | date) -> str:
         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}."
     )
@@ -298,22 +286,6 @@ def json_deserializer(s: str) -> Any:
     return replace_custom_stringified_objects(data)
 
 
-def convert_pydantic_to_dict(value: Any) -> Any:
-    """
-    Convert Pydantic models to dictionaries, including if they are in nested structures.
-    """
-    if isinstance(value, BaseModel):
-        return value.model_dump()
-    elif isinstance(value, dict):
-        return {k: convert_pydantic_to_dict(v) for k, v in value.items()}
-    elif isinstance(value, (list, tuple)):
-        return type(value)(convert_pydantic_to_dict(v) for v in value)
-    elif isinstance(value, set):
-        return {convert_pydantic_to_dict(v) for v in value}
-    else:
-        return value
-
-
 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/is_invalid.py

@@ -34,7 +34,7 @@ QUESTION_IS_INVALID_PROMPT = """Main signs about an invalid question (sometimes
   - Which could give an incentive only to specific participants to commit an immoral violent action, but are in practice unlikely.
   - Valid: Will the US be engaged in a military conflict with a UN member state in 2021? (It’s unlikely for the US to declare war in order to win a bet on this market).
   - Valid: Will Derek Chauvin go to jail for the murder of George Flyod? (It’s unlikely that the jurors would collude to make a wrong verdict in order to win this market).
-- Questions with relative dates will resolve as invalid. Dates must be stated in absolute terms, not relative depending on the current time. But they can be relative to the even specified in the question itself.
+- Questions with relative dates will resolve as invalid. Dates must be stated in absolute terms, not relative depending on the current time. But they can be relative to the event specified in the question itself.
 - Invalid: Who will be the president of the United States in 6 months? ("in 6 months depends on the current time").
 - Invalid: In the next 14 days, will Gnosis Chain gain another 1M users? ("in the next 14 days depends on the current time").
 - Valid: Will GNO price go up 10 days after Gnosis Pay cashback program is annouced? ("10 days after" is relative to the event in the question, so we can determine absolute value).

prediction_market_agent_tooling/tools/utils.py

@@ -28,6 +28,8 @@ LLM_SUPER_LOW_TEMPERATURE = 0.00000001
 # For consistent results, also include seed for models that supports it.
 LLM_SEED = 0
 
+BPS_CONSTANT = 10000
+
 
 def check_not_none(
     value: Optional[T],

{prediction_market_agent_tooling-0.56.0.dev1863.dist-info → prediction_market_agent_tooling-0.56.2.dev129.dist-info}/METADATA

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

{prediction_market_agent_tooling-0.56.0.dev1863.dist-info → prediction_market_agent_tooling-0.56.2.dev129.dist-info}/RECORD

@@ -16,8 +16,8 @@ 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=114f3V9abaok27p5jX3UVr5b5gRUiSxBIYn8Snid34I,6731
-prediction_market_agent_tooling/deploy/agent.py,sha256=v6jnk8gY_ckF_Z8Slj408RLBadC5cZwx_nqV02TiThU,22642
+prediction_market_agent_tooling/config.py,sha256=6iB8A4byexiemUajIw2SzRDQ8E8w0catyg7aH_mHpsY,6732
+prediction_market_agent_tooling/deploy/agent.py,sha256=dpc94DUo8Gq1LdRdw6k78vm_47OeJIfomG9CRVpgzk0,22757
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=dIIdZashExWk9tOdyDjw87AuUcGyM7jYxNChYrVK2dM,1001
 prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=kMrIE3wMv_IB6nJd_1DmDXDkEZhsXFOgyTd7JZ0gqHI,13068
 prediction_market_agent_tooling/deploy/constants.py,sha256=M5ty8URipYMGe_G-RzxRydK3AFL6CyvmqCraJUrLBnE,82
@@ -27,11 +27,11 @@ prediction_market_agent_tooling/deploy/gcp/utils.py,sha256=oyW0jgrUT2Tr49c7GlpcM
 prediction_market_agent_tooling/deploy/trade_interval.py,sha256=Xk9j45alQ_vrasGvsNyuW70XHIQ7wfvjoxNR3F6HYCw,1155
 prediction_market_agent_tooling/gtypes.py,sha256=tqp03PyY0Yhievl4XELfwAn0xOoecaTvBZ1Co6b-A7o,2541
 prediction_market_agent_tooling/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prediction_market_agent_tooling/jobs/jobs.py,sha256=I07yh0GJ-xhlvQaOUQB8xlSnihhcbU2c7DZ4ZND14c0,1246
-prediction_market_agent_tooling/jobs/jobs_models.py,sha256=I5uBTHJ2S1Wi3H4jDxxU7nsswSIP9r3BevHmljLh5Pg,1370
-prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=I2_vGrEJj1reSI8M377ab5QCsYNp_l4l4QeYEmDBkFM,3989
+prediction_market_agent_tooling/jobs/jobs_models.py,sha256=GOtsNm7URhzZM5fPY64r8m8Gz-sSsUhG1qmDoC7wGL8,2231
+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=OgB6bvDGfTAxbh6cDGD3XFO0iy0MAaOQvXEP6nw8xW8,12817
+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/categorize.py,sha256=jsoHWvZk9pU6n17oWSCcCxNNYVwlb_NXsZxKRI7vmsk,1301
 prediction_market_agent_tooling/markets/data_models.py,sha256=jMqrSFO_w2z-5N3PFVgZqTHdVdkzSDhhzky2lHsGGKA,3621
 prediction_market_agent_tooling/markets/manifold/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -40,21 +40,23 @@ prediction_market_agent_tooling/markets/manifold/data_models.py,sha256=ylXIEHymx
 prediction_market_agent_tooling/markets/manifold/manifold.py,sha256=qemQIwuFg4yf6egGWFp9lWpz1lXr02QiBeZ2akcT6II,5026
 prediction_market_agent_tooling/markets/manifold/utils.py,sha256=cPPFWXm3vCYH1jy7_ctJZuQH9ZDaPL4_AgAYzGWkoow,513
 prediction_market_agent_tooling/markets/market_fees.py,sha256=Q64T9uaJx0Vllt0BkrPmpMEz53ra-hMVY8Czi7CEP7s,1227
-prediction_market_agent_tooling/markets/markets.py,sha256=mwubc567OIlA32YKqlIdTloYV8FGJia9gPv0wE0xUEA,3368
+prediction_market_agent_tooling/markets/markets.py,sha256=_b-BAfoKIcXl5ZXVODi1ywMhRCbc52022csH1nQT084,3893
 prediction_market_agent_tooling/markets/metaculus/api.py,sha256=4TRPGytQQbSdf42DCg2M_JWYPAuNjqZ3eBqaQBLkNks,2736
 prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=Suxa7xELdYuFNKqvGvFh8qyfVtAg79E-vaQ6dqNZOtA,3261
-prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=E_TUf5q73lWzdMp40Ne-3w4MjEd7AHcaif4pvFh9FMU,4360
+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=nCjsc-ylIzQOCK_1BW-5NoYrS-NIXz2Hg9N1-IqhhC8,27516
-prediction_market_agent_tooling/markets/omen/omen.py,sha256=LqNZjngo6LoktKecfYmGmJJ9D5rj-s0Poy4x4_GZfp0,51116
+prediction_market_agent_tooling/markets/omen/data_models.py,sha256=0eky-RO0TuJysUXHd52A6DSU2mx1ZWiJvvntS4xQsUc,27794
+prediction_market_agent_tooling/markets/omen/omen.py,sha256=uOuV2DgQmxz6kzPcMovyGg0xYS0c6x12fEFNtLmN-uY,51260
 prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=Zq7SncCq-hvpgXKsVruGBGCn1OhKZTe7r1qLdCTrT2w,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=zQH3iu0SVH1RmE-W3NMEpcKVMILXJYxMhL6w1wh5RUo,37348
+prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=cXgtBfc5uv7d8598SJ537LxFGVfF_mv-VoQoqI4_G84,36330
 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
 prediction_market_agent_tooling/markets/polymarket/polymarket.py,sha256=NRoZK71PtH8kkangMqme7twcAXhRJSSabbmOir-UnAI,3418
 prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=m4JG6WULh5epCJt4XBMHg0ae5NoVhqlOvAl0A7DR9iM,2023
+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/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
@@ -69,7 +71,7 @@ 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=iHd_Qi4hMlzUIwT700i196A9ScaQCptKQPH1taQRGEQ,13859
+prediction_market_agent_tooling/tools/caches/db_cache.py,sha256=s8MKNWa3EFIRMZbi5YqgOd4S1boMPkUrGFgtW8qBNlw,12844
 prediction_market_agent_tooling/tools/caches/inmemory_cache.py,sha256=tGHHd9HCiE_hCCtPtloHZQdDfBuiow9YsqJNYi2Tx_0,499
 prediction_market_agent_tooling/tools/contract.py,sha256=s3yo8IbXTcvAJcPfLM0_NbgaEsWwLsPmyVnOgyjq_xI,20919
 prediction_market_agent_tooling/tools/costs.py,sha256=EaAJ7v9laD4VEV3d8B44M4u3_oEO_H16jRVCdoZ93Uw,954
@@ -81,7 +83,7 @@ prediction_market_agent_tooling/tools/httpx_cached_client.py,sha256=0-N1r0zcGKlY
 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=8A3U2uxsCsOfLjru-6R_PPIAuiKY4qFkWp_GSBPV6-s,1280
 prediction_market_agent_tooling/tools/ipfs/ipfs_handler.py,sha256=CTTMfTvs_8PH4kAtlQby2aeEKwgpmxtuGbd4oYIdJ2A,1201
-prediction_market_agent_tooling/tools/is_invalid.py,sha256=Gp8ASGmqXZGdKKQ4U2ZfQj6bx2Wngb4IExIfV54E4j4,5322
+prediction_market_agent_tooling/tools/is_invalid.py,sha256=GSMwSWUZy-xviaFoIl0L34AVfLLTdh7zegjsTFE7_1M,5323
 prediction_market_agent_tooling/tools/is_predictable.py,sha256=VGkxSoJ8CSLknloOLzm5J4-us7XImYxVzvpsAzxbpCc,6730
 prediction_market_agent_tooling/tools/langfuse_.py,sha256=jI_4ROxqo41CCnWGS1vN_AeDVhRzLMaQLxH3kxDu3L8,1153
 prediction_market_agent_tooling/tools/langfuse_client_utils.py,sha256=B0PhAQyviFnVbtOCYMxYmcCn66cu9nbqAOIAZcdgiRI,5771
@@ -95,10 +97,10 @@ prediction_market_agent_tooling/tools/singleton.py,sha256=CiIELUiI-OeS7U7eeHEt0r
 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/utils.py,sha256=W-9SqeCKd51BYMRhDjYPQ7lfNO_zE9EvYpmu2r5WXGA,7163
+prediction_market_agent_tooling/tools/utils.py,sha256=1VvunbTmzGzpIlRukFhArreFNxJPbsg4lLtQNk0r2bY,7185
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=44W8siSLNQxeib98bbwAe7V5C609NHNlUuxwuWIRDiY,11838
-prediction_market_agent_tooling-0.56.0.dev1863.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.56.0.dev1863.dist-info/METADATA,sha256=6sEM3cB9ZgytNkbgnHz2Y-IlHy86yV08HnWlf7B82nE,8114
-prediction_market_agent_tooling-0.56.0.dev1863.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-prediction_market_agent_tooling-0.56.0.dev1863.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.56.0.dev1863.dist-info/RECORD,,
+prediction_market_agent_tooling-0.56.2.dev129.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.56.2.dev129.dist-info/METADATA,sha256=uWLV8rw76xcE9yFjv1CYRp3mpM_HbYBFho1qpIyeoCc,8113
+prediction_market_agent_tooling-0.56.2.dev129.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+prediction_market_agent_tooling-0.56.2.dev129.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.56.2.dev129.dist-info/RECORD,,

prediction_market_agent_tooling/jobs/jobs.py

@@ -1,45 +0,0 @@
-import typing as t
-
-from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
-from prediction_market_agent_tooling.jobs.omen.omen_jobs import OmenJobAgentMarket
-from prediction_market_agent_tooling.markets.agent_market import FilterBy, SortBy
-from prediction_market_agent_tooling.markets.markets import MarketType
-
-JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET: dict[MarketType, type[JobAgentMarket]] = {
-    MarketType.OMEN: OmenJobAgentMarket,
-}
-
-
-@t.overload
-def get_jobs(
-    market_type: t.Literal[MarketType.OMEN],
-    limit: int | None,
-    filter_by: FilterBy = FilterBy.OPEN,
-    sort_by: SortBy = SortBy.NONE,
-) -> t.Sequence[OmenJobAgentMarket]:
-    ...
-
-
-@t.overload
-def get_jobs(
-    market_type: MarketType,
-    limit: int | None,
-    filter_by: FilterBy = FilterBy.OPEN,
-    sort_by: SortBy = SortBy.NONE,
-) -> t.Sequence[JobAgentMarket]:
-    ...
-
-
-def get_jobs(
-    market_type: MarketType,
-    limit: int | None,
-    filter_by: FilterBy = FilterBy.OPEN,
-    sort_by: SortBy = SortBy.NONE,
-) -> t.Sequence[JobAgentMarket]:
-    job_class = JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET[market_type]
-    markets = job_class.get_jobs(
-        limit=limit,
-        sort_by=sort_by,
-        filter_by=filter_by,
-    )
-    return markets