prediction-market-agent-tooling 0.67.1__tar.gz → 0.67.3__tar.gz

{prediction_market_agent_tooling-0.67.1 → prediction_market_agent_tooling-0.67.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.67.1
+Version: 0.67.3
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13
@@ -42,6 +42,7 @@ Requires-Dist: proto-plus (>=1.0.0,<2.0.0)
 Requires-Dist: protobuf (>=5.0.0,<6.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.9,<3.0.0)
 Requires-Dist: pydantic (>=2.6.1,<3.0.0)
+Requires-Dist: pydantic-ai (>=0.1.9,<1.0.0)
 Requires-Dist: pydantic-settings (>=2.4.0,<3.0.0)
 Requires-Dist: pymongo (>=4.8.0,<5.0.0)
 Requires-Dist: pytest-postgresql (>=6.1.1,<7.0.0)

prediction_market_agent_tooling-0.67.3/prediction_market_agent_tooling/abis/erc1155.abi.json

@@ -0,0 +1,352 @@
+[
+  {
+    "inputs": [],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "owner",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "Approval",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "from",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "Transfer",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "owner",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      }
+    ],
+    "name": "allowance",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "approve",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "account",
+        "type": "address"
+      }
+    ],
+    "name": "balanceOf",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "account",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "burn",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "decimals",
+    "outputs": [
+      {
+        "internalType": "uint8",
+        "name": "",
+        "type": "uint8"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "subtractedValue",
+        "type": "uint256"
+      }
+    ],
+    "name": "decreaseAllowance",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "factory",
+    "outputs": [
+      {
+        "internalType": "contract Wrapped1155Factory",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "addedValue",
+        "type": "uint256"
+      }
+    ],
+    "name": "increaseAllowance",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "account",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "mint",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "multiToken",
+    "outputs": [
+      {
+        "internalType": "contract IERC1155",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "name",
+    "outputs": [
+      {
+        "internalType": "string",
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "symbol",
+    "outputs": [
+      {
+        "internalType": "string",
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "tokenId",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "totalSupply",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "recipient",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "transfer",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "sender",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "recipient",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "transferFrom",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]

{prediction_market_agent_tooling-0.67.1 → prediction_market_agent_tooling-0.67.3}/prediction_market_agent_tooling/deploy/agent.py

@@ -6,6 +6,7 @@ from enum import Enum
 from functools import cached_property
 
 from pydantic import computed_field
+from pydantic_ai.exceptions import UnexpectedModelBehavior
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.betting_strategy import (
@@ -19,13 +20,13 @@ from prediction_market_agent_tooling.deploy.trade_interval import (
 )
 from prediction_market_agent_tooling.gtypes import USD, OutcomeToken, xDai
 from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.markets.agent_market import AgentMarket, FilterBy
-from prediction_market_agent_tooling.markets.agent_market import (
-    MarketType as AgentMarketType,
-)
 from prediction_market_agent_tooling.markets.agent_market import (
+    AgentMarket,
+    ConditionalFilterType,
+    FilterBy,
     ProcessedMarket,
     ProcessedTradedMarket,
+    QuestionType,
     SortBy,
 )
 from prediction_market_agent_tooling.markets.data_models import (
@@ -47,6 +48,9 @@ from prediction_market_agent_tooling.tools.custom_exceptions import (
 from prediction_market_agent_tooling.tools.is_invalid import is_invalid
 from prediction_market_agent_tooling.tools.is_predictable import is_predictable_binary
 from prediction_market_agent_tooling.tools.langfuse_ import langfuse_context, observe
+from prediction_market_agent_tooling.tools.rephrase import (
+    rephrase_question_to_unconditional,
+)
 from prediction_market_agent_tooling.tools.tokens.main_token import (
     MINIMUM_NATIVE_TOKEN_IN_EOA_FOR_FEES,
 )
@@ -196,6 +200,7 @@ class DeployablePredictionAgent(DeployableAgent):
     trade_on_markets_created_after: DatetimeUTC | None = None
     get_markets_sort_by: SortBy = SortBy.CLOSING_SOONEST
     get_markets_filter_by: FilterBy = FilterBy.OPEN
+    rephrase_conditional_markets: bool = True
 
     # Agent behaviour when filtering fetched markets
     allow_invalid_questions: bool = False
@@ -205,6 +210,8 @@ class DeployablePredictionAgent(DeployableAgent):
         MINIMUM_NATIVE_TOKEN_IN_EOA_FOR_FEES
     )
 
+    just_warn_on_unexpected_model_behavior: bool = False
+
     # Only Metaculus allows to post predictions without trading (buying/selling of outcome tokens).
     supported_markets: t.Sequence[MarketType] = [MarketType.METACULUS]
 
@@ -224,6 +231,7 @@ class DeployablePredictionAgent(DeployableAgent):
         self.answer_categorical_market = observe()(self.answer_categorical_market)  # type: ignore[method-assign]
         self.answer_scalar_market = observe()(self.answer_scalar_market)  # type: ignore[method-assign]
         self.process_market = observe()(self.process_market)  # type: ignore[method-assign]
+        self.rephrase_market_to_unconditional = observe()(self.rephrase_market_to_unconditional)  # type: ignore[method-assign]
 
     def update_langfuse_trace_by_market(
         self, market_type: MarketType, market: AgentMarket
@@ -298,6 +306,34 @@ class DeployablePredictionAgent(DeployableAgent):
 
         return True
 
+    def rephrase_market_to_unconditional(
+        self,
+        market_: AgentMarket,
+    ) -> AgentMarket:
+        """
+        If `rephrase_conditional_markets` is set to True,
+        this method will be used to rephrase the question to account for the parent's market probability in the agent's decision process.
+        """
+        new = market_.model_copy(deep=True)
+
+        if new.parent is not None and new.parent.market.parent is not None:
+            new.parent.market = self.rephrase_market_to_unconditional(new.parent.market)
+
+        rephrased_question = (
+            rephrase_question_to_unconditional(
+                new.question,
+                new.parent.market.question,
+                new.parent.market.outcomes[new.parent.parent_outcome],
+            )
+            if new.parent is not None
+            else new.question
+        )
+
+        new.question = rephrased_question
+        new.parent = None
+
+        return new
+
     def answer_categorical_market(
         self, market: AgentMarket
     ) -> CategoricalProbabilisticAnswer | None:
@@ -338,13 +374,19 @@ class DeployablePredictionAgent(DeployableAgent):
         return False
 
     @property
-    def agent_market_type(self) -> AgentMarketType:
+    def conditional_filter_type(self) -> ConditionalFilterType:
+        if self.rephrase_conditional_markets:
+            return ConditionalFilterType.ALL
+        return ConditionalFilterType.ONLY_NOT_CONDITIONAL
+
+    @property
+    def agent_question_type(self) -> QuestionType:
         if self.fetch_scalar_markets:
-            return AgentMarketType.SCALAR
+            return QuestionType.SCALAR
         elif self.fetch_categorical_markets:
-            return AgentMarketType.CATEGORICAL
+            return QuestionType.CATEGORICAL
         else:
-            return AgentMarketType.BINARY
+            return QuestionType.BINARY
 
     def get_markets(
         self,
@@ -355,15 +397,14 @@ class DeployablePredictionAgent(DeployableAgent):
         """
         cls = market_type.market_class
 
-        agent_market_type = self.agent_market_type
-
         # Fetch the soonest closing markets to choose from
         available_markets = cls.get_markets(
             limit=self.n_markets_to_fetch,
             sort_by=self.get_markets_sort_by,
             filter_by=self.get_markets_filter_by,
             created_after=self.trade_on_markets_created_after,
-            market_type=agent_market_type,
+            question_type=self.agent_question_type,
+            conditional_filter_type=self.conditional_filter_type,
         )
         return available_markets
 
@@ -396,6 +437,9 @@ class DeployablePredictionAgent(DeployableAgent):
 
         logger.info(f"Answering market '{market.question}'.")
 
+        if self.rephrase_conditional_markets and market.parent is not None:
+            market = self.rephrase_market_to_unconditional(market)
+
         if market.is_binary:
             try:
                 binary_answer = self.answer_binary_market(market)
@@ -455,9 +499,18 @@ class DeployablePredictionAgent(DeployableAgent):
             f"Processing market {market.question=} from {market.url=} with liquidity {market.get_liquidity()}."
         )
 
-        answer = self.build_answer(
-            market=market, market_type=market_type, verify_market=verify_market
-        )
+        try:
+            answer = self.build_answer(
+                market=market, market_type=market_type, verify_market=verify_market
+            )
+        except UnexpectedModelBehavior:
+            (
+                logger.warning
+                if self.just_warn_on_unexpected_model_behavior
+                else logger.exception
+            )(f"Unexpected model behaviour in {self.__class__.__name__}.")
+            answer = None
+
         if answer is not None:
             self.verify_answer_outcomes(market=market, answer=answer)
 
@@ -577,6 +630,7 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         super().initialize_langfuse()
         # Auto-observe all the methods where it makes sense, so that subclassses don't need to do it manually.
         self.build_trades = observe()(self.build_trades)  # type: ignore[method-assign]
+        self.execute_trades = observe()(self.execute_trades)  # type: ignore[method-assign]
 
     def check_min_required_balance_to_trade(self, market: AgentMarket) -> None:
         api_keys = APIKeys()
@@ -622,37 +676,9 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         trades = strategy.calculate_trades(existing_position, answer, market)
         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:
-        processed_market = super().process_market(market_type, market, verify_market)
-        if processed_market is None:
-            return None
-
-        api_keys = APIKeys()
-        user_id = market.get_user_id(api_keys=api_keys)
-
-        try:
-            existing_position = market.get_position(user_id=user_id)
-        except Exception as e:
-            logger.warning(f"Could not get position for user {user_id}, exception {e}")
-            return None
-
-        trades = self.build_trades(
-            market=market,
-            answer=processed_market.answer,
-            existing_position=existing_position,
-        )
-
+    def execute_trades(
+        self, market: AgentMarket, trades: list[Trade]
+    ) -> list[PlacedTrade]:
         # It can take quite some time before agent processes all the markets, recheck here if the market didn't get closed in the meantime, to not error out completely.
         # Unfortunately, we can not just add some room into closing time of the market while fetching them, because liquidity can be removed at any time by the liquidity providers.
         still_tradeable = market.can_be_traded()
@@ -661,7 +687,8 @@ class DeployableTraderAgent(DeployablePredictionAgent):
                 f"Market {market.question=} ({market.url}) was selected to processing, but is not tradeable anymore."
             )
 
-        placed_trades = []
+        placed_trades: list[PlacedTrade] = []
+
         for trade in trades:
             logger.info(f"Executing trade {trade} on market {market.id} ({market.url})")
 
@@ -674,7 +701,9 @@ class DeployableTraderAgent(DeployablePredictionAgent):
                     case TradeType.SELL:
                         # Get actual value of the position we are going to sell, and if it's less than we wanted to sell, simply sell all of it.
                         current_position = check_not_none(
-                            market.get_position(user_id),
+                            market.get_position(
+                                market.get_user_id(api_keys=self.api_keys)
+                            ),
                             "Should exists if we are going to sell outcomes.",
                         )
 
@@ -702,6 +731,39 @@ class DeployableTraderAgent(DeployablePredictionAgent):
                     f"Trade execution skipped because, {self.place_trades=} or {still_tradeable=}."
                 )
 
+        return placed_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:
+        processed_market = super().process_market(market_type, market, verify_market)
+        if processed_market is None:
+            return None
+
+        user_id = market.get_user_id(api_keys=self.api_keys)
+
+        try:
+            existing_position = market.get_position(user_id=user_id)
+        except Exception as e:
+            logger.warning(f"Could not get position for user {user_id}, exception {e}")
+            return None
+
+        trades = self.build_trades(
+            market=market,
+            answer=processed_market.answer,
+            existing_position=existing_position,
+        )
+        placed_trades = self.execute_trades(market, trades)
+
         traded_market = ProcessedTradedMarket(
             answer=processed_market.answer, trades=placed_trades
         )

{prediction_market_agent_tooling-0.67.1 → prediction_market_agent_tooling-0.67.3}/prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -84,7 +84,7 @@ class BettingStrategy(ABC):
 
                 if outcome_tokens_to_get_in_usd <= trade.amount:
                     raise GuaranteedLossError(
-                        f"Trade {trade=} would result in guaranteed loss by getting only {outcome_tokens_to_get=}. Halting execution."
+                        f"Trade {trade=} on market {market.url=} would result in guaranteed loss by getting only {outcome_tokens_to_get=}. Halting execution."
                     )
 
             clean_trades.append(trade)

{prediction_market_agent_tooling-0.67.1 → prediction_market_agent_tooling-0.67.3}/prediction_market_agent_tooling/markets/agent_market.py

@@ -64,13 +64,24 @@ class FilterBy(str, Enum):
     NONE = "none"
 
 
-class MarketType(str, Enum):
+class ParentMarket(BaseModel):
+    market: "AgentMarket"
+    parent_outcome: int
+
+
+class QuestionType(str, Enum):
     ALL = "all"
     CATEGORICAL = "categorical"
     SCALAR = "scalar"
     BINARY = "binary"
 
 
+class ConditionalFilterType(Enum):
+    ALL = 1
+    ONLY_CONDITIONAL = 2
+    ONLY_NOT_CONDITIONAL = 3
+
+
 class AgentMarket(BaseModel):
     """
     Common market class that can be created from vendor specific markets.
@@ -96,6 +107,8 @@ class AgentMarket(BaseModel):
     upper_bound: Wei | None = None
     lower_bound: Wei | None = None
 
+    parent: ParentMarket | None = None
+
     @field_validator("probabilities")
     def validate_probabilities(
         cls,
@@ -376,8 +389,8 @@ class AgentMarket(BaseModel):
         filter_by: FilterBy = FilterBy.OPEN,
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
-        market_type: MarketType = MarketType.ALL,
-        include_conditional_markets: bool = False,
+        question_type: QuestionType = QuestionType.ALL,
+        conditional_filter_type: ConditionalFilterType = ConditionalFilterType.ONLY_NOT_CONDITIONAL,
     ) -> t.Sequence["AgentMarket"]:
         raise NotImplementedError("Subclasses must implement this method")