prediction-market-agent-tooling 0.64.12.dev660__py3-none-any.whl → 0.65.0__py3-none-any.whl

prediction_market_agent_tooling/markets/manifold/manifold.py

@@ -1,11 +1,10 @@
 import typing as t
-from math import ceil
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import (
     USD,
     CollateralToken,
-    Mana,
+    OutcomeStr,
     Probability,
 )
 from prediction_market_agent_tooling.markets.agent_market import (
@@ -25,9 +24,6 @@ from prediction_market_agent_tooling.markets.manifold.data_models import (
     FullManifoldMarket,
     usd_to_mana,
 )
-from prediction_market_agent_tooling.tools.betting_strategies.minimum_bet_to_win import (
-    minimum_bet_to_win,
-)
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
 
@@ -45,22 +41,17 @@ class ManifoldAgentMarket(AgentMarket):
         absolute=0.25,  # For doing trades via API.
     )
 
+    # We restrict Manifold to binary markets, hence current_p_yes always defined.
+    current_p_yes: Probability
+
     def get_last_trade_p_yes(self) -> Probability:
         """On Manifold, probablities aren't updated after the closure, so we can just use the current probability"""
         return self.current_p_yes
 
-    def get_last_trade_p_no(self) -> Probability:
-        """On Manifold, probablities aren't updated after the closure, so we can just use the current probability"""
-        return self.current_p_no
-
     def get_tiny_bet_amount(self) -> CollateralToken:
         return CollateralToken(1)
 
-    def get_minimum_bet_to_win(self, answer: bool, amount_to_win: float) -> Mana:
-        # Manifold lowest bet is 1 Mana, so we need to ceil the result.
-        return Mana(ceil(minimum_bet_to_win(answer, amount_to_win, self)))
-
-    def place_bet(self, outcome: bool, amount: USD) -> str:
+    def place_bet(self, outcome: OutcomeStr, amount: USD) -> str:
         self.get_usd_in_token(amount)
         bet = place_bet(
             amount=usd_to_mana(amount),
@@ -72,6 +63,15 @@ class ManifoldAgentMarket(AgentMarket):
 
     @staticmethod
     def from_data_model(model: FullManifoldMarket) -> "ManifoldAgentMarket":
+        outcome_token_pool = {o: model.pool.size_for_outcome(o) for o in model.outcomes}
+
+        prob_map = AgentMarket.build_probability_map(
+            outcomes=list(outcome_token_pool.keys()),
+            outcome_token_amounts=list(
+                [i.as_outcome_wei for i in outcome_token_pool.values()]
+            ),
+        )
+
         return ManifoldAgentMarket(
             id=model.id,
             question=model.question,
@@ -83,18 +83,18 @@ class ManifoldAgentMarket(AgentMarket):
             current_p_yes=model.probability,
             url=model.url,
             volume=model.volume,
-            outcome_token_pool={
-                o: model.pool.size_for_outcome(o) for o in model.outcomes
-            },
+            outcome_token_pool=outcome_token_pool,
+            probabilities=prob_map,
         )
 
     @staticmethod
-    def get_binary_markets(
+    def get_markets(
         limit: int,
         sort_by: SortBy,
         filter_by: FilterBy = FilterBy.OPEN,
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
+        fetch_categorical_markets: bool = False,
     ) -> t.Sequence["ManifoldAgentMarket"]:
         sort: t.Literal["newest", "close-date"] | None
         if sort_by == SortBy.CLOSING_SOONEST:

prediction_market_agent_tooling/markets/manifold/utils.py

@@ -1,15 +1,10 @@
+import typing as t
+
+from prediction_market_agent_tooling.gtypes import OutcomeStr
 from prediction_market_agent_tooling.markets.data_models import Resolution
-from prediction_market_agent_tooling.markets.manifold.api import (
-    get_manifold_binary_markets,
-)
 
 
-def find_resolution_on_manifold(question: str, n: int = 100) -> Resolution | None:
-    # Even with exact-match search, Manifold doesn't return it as the first result, increase `n` if you can't find market that you know exists.
-    manifold_markets = get_manifold_binary_markets(
-        n, term=question, filter_=None, sort=None
-    )
-    for manifold_market in manifold_markets:
-        if manifold_market.question == question:
-            return manifold_market.resolution
-    return None
+def validate_resolution(v: t.Any) -> Resolution:
+    if isinstance(v, str):
+        return Resolution(outcome=OutcomeStr(v), invalid=False)
+    raise ValueError(f"Expected a string, got {v} {type(v)}")

prediction_market_agent_tooling/markets/markets.py

@@ -69,6 +69,7 @@ MARKET_TYPE_TO_AGENT_MARKET: dict[MarketType, type[AgentMarket]] = {
     MarketType.SEER: SeerAgentMarket,
 }
 
+
 JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET: dict[MarketType, type[JobAgentMarket]] = {
     MarketType.OMEN: OmenJobAgentMarket,
 }
@@ -83,7 +84,7 @@ def get_binary_markets(
     created_after: DatetimeUTC | None = None,
 ) -> t.Sequence[AgentMarket]:
     agent_market_class = MARKET_TYPE_TO_AGENT_MARKET[market_type]
-    markets = agent_market_class.get_binary_markets(
+    markets = agent_market_class.get_markets(
         limit=limit,
         sort_by=sort_by,
         filter_by=filter_by,

prediction_market_agent_tooling/markets/metaculus/metaculus.py

@@ -1,6 +1,11 @@
 import typing as t
 
+from pydantic import field_validator
+from pydantic_core.core_schema import FieldValidationInfo
+
 from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.gtypes import OutcomeStr, Probability
+from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
@@ -32,14 +37,29 @@ class MetaculusAgentMarket(AgentMarket):
     resolution_criteria: str
     fees: MarketFees = MarketFees.get_zero_fees()  # No fees on Metaculus.
 
+    @field_validator("probabilities")
+    def validate_probabilities(
+        cls,
+        probs: dict[OutcomeStr, Probability],
+        info: FieldValidationInfo,
+    ) -> dict[OutcomeStr, Probability]:
+        outcomes: t.Sequence[OutcomeStr] = check_not_none(info.data.get("outcomes"))
+        # We don't check for outcomes match because Metaculus has no filled outcomes.
+        total = float(sum(probs.values()))
+        if not 0.999 <= total <= 1.001:
+            # We simply log a warning because for some use-cases (e.g. existing positions), the
+            # markets might be already closed hence no reliable outcome token prices exist anymore.
+            logger.warning(f"Probabilities for market {info.data=} do not sum to 1.")
+        return probs
+
     @staticmethod
     def from_data_model(model: MetaculusQuestion) -> "MetaculusAgentMarket":
+        probabilities = AgentMarket.build_probability_map_from_p_yes(p_yes=model.p_yes)
         return MetaculusAgentMarket(
             id=str(model.id),
             question=model.title,
             outcomes=[],
             resolution=None,
-            current_p_yes=model.p_yes,
             created_time=model.created_at,
             close_time=model.scheduled_close_time,
             url=model.page_url,
@@ -49,10 +69,11 @@ class MetaculusAgentMarket(AgentMarket):
             description=model.question.description,
             fine_print=model.question.fine_print,
             resolution_criteria=model.question.resolution_criteria,
+            probabilities=probabilities,
         )
 
     @staticmethod
-    def get_binary_markets(
+    def get_markets(
         limit: int,
         sort_by: SortBy = SortBy.NONE,
         filter_by: FilterBy = FilterBy.OPEN,
@@ -109,8 +130,12 @@ class MetaculusAgentMarket(AgentMarket):
     def store_prediction(
         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)
+        if (
+            processed_market is not None
+            and processed_market.answer.get_yes_probability() is not None
+        ):
+            yes_prob = check_not_none(processed_market.answer.get_yes_probability())
+            make_prediction(self.id, yes_prob)
             post_question_comment(
                 self.id,
                 check_not_none(

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -63,7 +63,7 @@ def get_boolean_outcome(outcome_str: str) -> bool:
     raise ValueError(f"Outcome `{outcome_str}` is not a valid boolean outcome.")
 
 
-def get_bet_outcome(binary_outcome: bool) -> str:
+def get_bet_outcome(binary_outcome: bool) -> OutcomeStr:
     return OMEN_TRUE_OUTCOME if binary_outcome else OMEN_FALSE_OUTCOME
 
 
@@ -399,31 +399,16 @@ class OmenMarket(BaseModel):
     def is_binary(self) -> bool:
         return len(self.outcomes) == 2
 
-    def boolean_outcome_from_answer(self, answer: HexBytes) -> bool:
-        if not self.is_binary:
-            raise ValueError(
-                f"Market with title {self.title} is not binary, it has {len(self.outcomes)} outcomes."
-            )
-        outcome: str = self.outcomes[answer.as_int()]
-        return get_boolean_outcome(outcome)
-
-    @property
-    def boolean_outcome(self) -> bool:
-        if not self.is_resolved_with_valid_answer:
-            raise ValueError(f"Bet with title {self.title} is not resolved.")
-        return self.boolean_outcome_from_answer(
-            check_not_none(
-                self.currentAnswer, "Can not be None if `is_resolved_with_valid_answer`"
-            )
-        )
+    def outcome_from_answer(self, answer: HexBytes) -> OutcomeStr | None:
+        if answer == INVALID_ANSWER_HEX_BYTES:
+            return None
+        return self.outcomes[answer.as_int()]
 
     def get_resolution_enum_from_answer(self, answer: HexBytes) -> Resolution:
-        if answer == INVALID_ANSWER_HEX_BYTES:
-            return Resolution.CANCEL
-        elif self.boolean_outcome_from_answer(answer):
-            return Resolution.YES
-        else:
-            return Resolution.NO
+        if outcome := self.outcome_from_answer(answer):
+            return Resolution.from_answer(outcome)
+
+        return Resolution(outcome=None, invalid=True)
 
     def get_resolution_enum(self) -> t.Optional[Resolution]:
         if not self.is_resolved_with_valid_answer:
@@ -561,10 +546,6 @@ class OmenBet(BaseModel):
     def creation_datetime(self) -> DatetimeUTC:
         return DatetimeUTC.to_datetime_utc(self.creationTimestamp)
 
-    @property
-    def boolean_outcome(self) -> bool:
-        return get_boolean_outcome(self.fpmm.outcomes[self.outcomeIndex])
-
     @property
     def old_probability(self) -> Probability:
         # Old marginal price is the probability of the outcome before placing this bet.
@@ -582,9 +563,13 @@ class OmenBet(BaseModel):
 
     def get_profit(self) -> CollateralToken:
         bet_amount = self.collateral_amount_token
+
+        if not self.fpmm.has_valid_answer:
+            return CollateralToken(0)
+
         profit = (
             self.outcomeTokensTraded.as_outcome_token.as_token - bet_amount
-            if self.boolean_outcome == self.fpmm.boolean_outcome
+            if self.outcomeIndex == self.fpmm.answer_index
             else -bet_amount
         )
         return profit
@@ -594,7 +579,7 @@ class OmenBet(BaseModel):
             id=str(self.transactionHash),
             # Use the transaction hash instead of the bet id - both are valid, but we return the transaction hash from the trade functions, so be consistent here.
             amount=self.collateral_amount_token,
-            outcome=self.boolean_outcome,
+            outcome=self.fpmm.outcomes[self.outcomeIndex],
             created_time=self.creation_datetime,
             market_question=self.title,
             market_id=self.fpmm.id,
@@ -610,11 +595,11 @@ class OmenBet(BaseModel):
             id=self.transactionHash.hex(),
             # Use the transaction hash instead of the bet id - both are valid, but we return the transaction hash from the trade functions, so be consistent here.
             amount=self.collateral_amount_token,
-            outcome=self.boolean_outcome,
+            outcome=self.fpmm.outcomes[self.outcomeIndex],
             created_time=self.creation_datetime,
             market_question=self.title,
             market_id=self.fpmm.id,
-            market_outcome=self.fpmm.boolean_outcome,
+            market_outcome=self.fpmm.outcomes[self.outcomeIndex],
             resolved_time=check_not_none(self.fpmm.finalized_datetime),
             profit=self.get_profit(),
         )