prediction-market-agent-tooling 0.56.0.dev1863__tar.gz → 0.56.1__tar.gz

{prediction_market_agent_tooling-0.56.0.dev1863 → prediction_market_agent_tooling-0.56.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.56.0.dev1863
+Version: 0.56.1
 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 → prediction_market_agent_tooling-0.56.1}/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-0.56.0.dev1863 → prediction_market_agent_tooling-0.56.1}/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-0.56.1/prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -0,0 +1,140 @@
+import typing as t
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.deploy.betting_strategy import (
+    Currency,
+    KellyBettingStrategy,
+    TradeType,
+)
+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,
+    OmenMarket,
+)
+from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
+    FilterBy,
+    OmenSubgraphHandler,
+    SortBy,
+)
+from prediction_market_agent_tooling.tools.utils import DatetimeUTC
+
+
+class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
+    CATEGORY = "jobs"
+
+    @property
+    def job(self) -> str:
+        """Omen market's have only question, so that's where the job description is."""
+        return self.question
+
+    @property
+    def deadline(self) -> DatetimeUTC:
+        return self.close_time
+
+    def get_reward(self, max_bond: float) -> float:
+        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 = FilterBy.OPEN,
+        sort_by: SortBy = SortBy.CLOSING_SOONEST,
+    ) -> t.Sequence["OmenJobAgentMarket"]:
+        markets = OmenSubgraphHandler().get_omen_binary_markets_simple(
+            limit=limit,
+            filter_by=filter_by,
+            sort_by=sort_by,
+            category=cls.CATEGORY,
+        )
+        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(
+            OmenAgentMarket.from_data_model(market)
+        )
+
+    @staticmethod
+    def from_omen_agent_market(market: OmenAgentMarket) -> "OmenJobAgentMarket":
+        return OmenJobAgentMarket(
+            id=market.id,
+            question=market.question,
+            description=market.description,
+            outcomes=market.outcomes,
+            outcome_token_pool=market.outcome_token_pool,
+            resolution=market.resolution,
+            created_time=market.created_time,
+            close_time=market.close_time,
+            current_p_yes=market.current_p_yes,
+            url=market.url,
+            volume=market.volume,
+            creator=market.creator,
+            collateral_token_contract_address_checksummed=market.collateral_token_contract_address_checksummed,
+            market_maker_contract_address_checksummed=market.market_maker_contract_address_checksummed,
+            condition=market.condition,
+            finalized_time=market.finalized_time,
+            fees=market.fees,
+        )

{prediction_market_agent_tooling-0.56.0.dev1863 → prediction_market_agent_tooling-0.56.1}/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-0.56.1/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-0.56.0.dev1863 → prediction_market_agent_tooling-0.56.1}/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-0.56.0.dev1863 → prediction_market_agent_tooling-0.56.1}/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-0.56.0.dev1863 → prediction_market_agent_tooling-0.56.1}/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-0.56.0.dev1863 → prediction_market_agent_tooling-0.56.1}/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,
     )