prediction-market-agent-tooling 0.65.5__py3-none-any.whl → 0.69.17.dev1149__py3-none-any.whl

prediction_market_agent_tooling/markets/data_models.py

@@ -1,11 +1,15 @@
 from enum import Enum
-from typing import Annotated
+from typing import Annotated, Any, Sequence
 
-from pydantic import BaseModel, BeforeValidator, computed_field
+from pydantic import BaseModel, BeforeValidator, computed_field, model_validator
 
 from prediction_market_agent_tooling.deploy.constants import (
+    DOWN_OUTCOME_LOWERCASE_IDENTIFIER,
+    INVALID_OUTCOME_LOWERCASE_IDENTIFIER,
     NO_OUTCOME_LOWERCASE_IDENTIFIER,
+    UP_OUTCOME_LOWERCASE_IDENTIFIER,
     YES_OUTCOME_LOWERCASE_IDENTIFIER,
+    is_invalid_outcome,
 )
 from prediction_market_agent_tooling.gtypes import (
     USD,
@@ -13,8 +17,13 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeStr,
     OutcomeToken,
     Probability,
+    Wei,
 )
 from prediction_market_agent_tooling.logprobs_parser import FieldLogprobs
+from prediction_market_agent_tooling.markets.omen.omen_constants import (
+    OMEN_FALSE_OUTCOME,
+    OMEN_TRUE_OUTCOME,
+)
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC, check_not_none
 
 
@@ -26,6 +35,26 @@ class Resolution(BaseModel):
     def from_answer(answer: OutcomeStr) -> "Resolution":
         return Resolution(outcome=answer, invalid=False)
 
+    def find_outcome_matching_market(
+        self, market_outcomes: Sequence[OutcomeStr]
+    ) -> OutcomeStr | None:
+        """
+        Finds a matching outcome in the provided market outcomes.
+
+        Performs case-insensitive matching between this resolution's outcome
+        and the provided market outcomes.
+
+        """
+
+        if not self.outcome:
+            return None
+
+        normalized_outcome = self.outcome.lower()
+        for outcome in market_outcomes:
+            if outcome.lower() == normalized_outcome:
+                return outcome
+        return None
+
 
 class Bet(BaseModel):
     id: str
@@ -76,6 +105,31 @@ def to_boolean_outcome(value: str | bool) -> bool:
 Decision = Annotated[bool, BeforeValidator(to_boolean_outcome)]
 
 
+class ScalarProbabilisticAnswer(BaseModel):
+    scalar_value: Wei
+    upperBound: Wei
+    lowerBound: Wei
+    confidence: float
+    reasoning: str | None = None
+    logprobs: list[FieldLogprobs] | None = None
+
+    @property
+    def p_up(self) -> Probability:
+        if self.scalar_value > self.upperBound:
+            return Probability(1)
+        elif self.scalar_value < self.lowerBound:
+            return Probability(0)
+        else:
+            return Probability(
+                (self.scalar_value - self.lowerBound)
+                / (self.upperBound - self.lowerBound)
+            )
+
+    @property
+    def p_down(self) -> Probability:
+        return Probability(1 - self.p_up)
+
+
 class ProbabilisticAnswer(BaseModel):
     p_yes: Probability
     confidence: float
@@ -104,6 +158,15 @@ class CategoricalProbabilisticAnswer(BaseModel):
     confidence: float
     reasoning: str | None = None
 
+    @model_validator(mode="before")
+    @classmethod
+    def _model_validator(cls, data: Any) -> Any:
+        if "p_yes" in data:
+            return CategoricalProbabilisticAnswer.from_probabilistic_answer(
+                ProbabilisticAnswer.model_validate(data)
+            ).model_dump()
+        return data
+
     @property
     def probable_resolution(self) -> Resolution:
         most_likely_outcome = max(
@@ -122,18 +185,57 @@ class CategoricalProbabilisticAnswer(BaseModel):
     @staticmethod
     def from_probabilistic_answer(
         answer: ProbabilisticAnswer,
+        market_outcomes: Sequence[OutcomeStr] | None = None,
     ) -> "CategoricalProbabilisticAnswer":
         return CategoricalProbabilisticAnswer(
             probabilities={
-                OutcomeStr(YES_OUTCOME_LOWERCASE_IDENTIFIER): answer.p_yes,
-                OutcomeStr(NO_OUTCOME_LOWERCASE_IDENTIFIER): Probability(
-                    1 - answer.p_yes
-                ),
+                (
+                    OMEN_TRUE_OUTCOME
+                    if market_outcomes and OMEN_TRUE_OUTCOME in market_outcomes
+                    else OutcomeStr(YES_OUTCOME_LOWERCASE_IDENTIFIER)
+                ): answer.p_yes,
+                (
+                    OMEN_FALSE_OUTCOME
+                    if market_outcomes and OMEN_FALSE_OUTCOME in market_outcomes
+                    else OutcomeStr(NO_OUTCOME_LOWERCASE_IDENTIFIER)
+                ): Probability(1 - answer.p_yes),
             },
             confidence=answer.confidence,
             reasoning=answer.reasoning,
         )
 
+    @staticmethod
+    def from_scalar_answer(
+        answer: ScalarProbabilisticAnswer,
+        market_outcomes: Sequence[OutcomeStr],
+    ) -> "CategoricalProbabilisticAnswer":
+        probabilities = {}
+        lowercase_market_outcomes = [outcome.lower() for outcome in market_outcomes]
+
+        if not set(
+            [
+                DOWN_OUTCOME_LOWERCASE_IDENTIFIER,
+                UP_OUTCOME_LOWERCASE_IDENTIFIER,
+            ]
+        ).issubset(lowercase_market_outcomes):
+            raise ValueError("Market with no outcomes")
+
+        probabilities[OutcomeStr(UP_OUTCOME_LOWERCASE_IDENTIFIER.upper())] = answer.p_up
+        probabilities[
+            OutcomeStr(DOWN_OUTCOME_LOWERCASE_IDENTIFIER.upper())
+        ] = answer.p_down
+
+        if market_outcomes and any(is_invalid_outcome(o) for o in market_outcomes):
+            probabilities[
+                OutcomeStr(INVALID_OUTCOME_LOWERCASE_IDENTIFIER.capitalize())
+            ] = Probability(1 - answer.p_up - answer.p_down)
+
+        return CategoricalProbabilisticAnswer(
+            probabilities=probabilities,
+            confidence=answer.confidence,
+            reasoning=answer.reasoning,
+        )
+
     def probability_for_market_outcome(self, market_outcome: OutcomeStr) -> Probability:
         for k, v in self.probabilities.items():
             if k.lower() == market_outcome.lower():
@@ -195,9 +297,20 @@ class Trade(BaseModel):
     outcome: OutcomeStr
     amount: USD
 
+    @model_validator(mode="before")
+    @classmethod
+    def _model_validator(cls, data: Any) -> Any:
+        if isinstance(data["outcome"], bool):
+            data["outcome"] = (
+                YES_OUTCOME_LOWERCASE_IDENTIFIER
+                if data["outcome"]
+                else NO_OUTCOME_LOWERCASE_IDENTIFIER
+            )
+        return data
+
 
 class PlacedTrade(Trade):
-    id: str | None = None
+    id: str
 
     @staticmethod
     def from_trade(trade: Trade, id: str) -> "PlacedTrade":

prediction_market_agent_tooling/markets/manifold/data_models.py

@@ -12,7 +12,9 @@ from prediction_market_agent_tooling.gtypes import (
     Probability,
 )
 from prediction_market_agent_tooling.markets.data_models import Resolution
-from prediction_market_agent_tooling.markets.manifold.utils import validate_resolution
+from prediction_market_agent_tooling.markets.manifold.utils import (
+    validate_manifold_resolution,
+)
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC, should_not_happen
 
 MANIFOLD_BASE_URL = "https://manifold.markets"
@@ -110,7 +112,7 @@ class ManifoldMarket(BaseModel):
 
     @field_validator("resolution", mode="before")
     def validate_resolution(cls, v: t.Any) -> Resolution:
-        return validate_resolution(v)
+        return validate_manifold_resolution(v)
 
     def __repr__(self) -> str:
         return f"Manifold's market: {self.question}"
@@ -204,7 +206,7 @@ class ManifoldBet(BaseModel):
 
     @field_validator("outcome", mode="before")
     def validate_resolution(cls, v: t.Any) -> Resolution:
-        return validate_resolution(v)
+        return validate_manifold_resolution(v)
 
     def get_resolved_outcome(self) -> OutcomeStr:
         if self.outcome.outcome:

prediction_market_agent_tooling/markets/manifold/manifold.py

@@ -1,4 +1,5 @@
 import typing as t
+from datetime import timedelta
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import (
@@ -9,12 +10,15 @@ from prediction_market_agent_tooling.gtypes import (
 )
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
+    ConditionalFilterType,
     FilterBy,
     MarketFees,
+    QuestionType,
     SortBy,
 )
 from prediction_market_agent_tooling.markets.manifold.api import (
     get_authenticated_user,
+    get_manifold_bets,
     get_manifold_binary_markets,
     get_manifold_market,
     place_bet,
@@ -24,7 +28,7 @@ from prediction_market_agent_tooling.markets.manifold.data_models import (
     FullManifoldMarket,
     usd_to_mana,
 )
-from prediction_market_agent_tooling.tools.utils import DatetimeUTC
+from prediction_market_agent_tooling.tools.utils import DatetimeUTC, utcnow
 
 
 class ManifoldAgentMarket(AgentMarket):
@@ -51,6 +55,20 @@ class ManifoldAgentMarket(AgentMarket):
     def get_tiny_bet_amount(self) -> CollateralToken:
         return CollateralToken(1)
 
+    def have_bet_on_market_since(self, keys: APIKeys, since: timedelta) -> bool:
+        start_time = utcnow() - since
+        recently_betted_questions = set(
+            get_manifold_market(b.contractId).question
+            for b in get_manifold_bets(
+                user_id=get_authenticated_user(
+                    keys.manifold_api_key.get_secret_value()
+                ).id,
+                start_time=start_time,
+                end_time=None,
+            )
+        )
+        return self.question in recently_betted_questions
+
     def place_bet(self, outcome: OutcomeStr, amount: USD) -> str:
         self.get_usd_in_token(amount)
         bet = place_bet(
@@ -94,7 +112,8 @@ class ManifoldAgentMarket(AgentMarket):
         filter_by: FilterBy = FilterBy.OPEN,
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
-        fetch_categorical_markets: bool = False,
+        question_type: QuestionType = QuestionType.ALL,
+        conditional_filter_type: ConditionalFilterType = ConditionalFilterType.ONLY_NOT_CONDITIONAL,
     ) -> t.Sequence["ManifoldAgentMarket"]:
         sort: t.Literal["newest", "close-date"] | None
         if sort_by == SortBy.CLOSING_SOONEST:

prediction_market_agent_tooling/markets/manifold/utils.py

@@ -3,8 +3,14 @@ import typing as t
 from prediction_market_agent_tooling.gtypes import OutcomeStr
 from prediction_market_agent_tooling.markets.data_models import Resolution
 
+MANIFOLD_CANCEL_OUTCOME = "CANCEL"
 
-def validate_resolution(v: t.Any) -> Resolution:
+
+def validate_manifold_resolution(v: t.Any) -> Resolution:
     if isinstance(v, str):
-        return Resolution(outcome=OutcomeStr(v), invalid=False)
+        return (
+            Resolution(outcome=OutcomeStr(v), invalid=False)
+            if v != MANIFOLD_CANCEL_OUTCOME
+            else Resolution(outcome=None, invalid=True)
+        )
     raise ValueError(f"Expected a string, got {v} {type(v)}")

prediction_market_agent_tooling/markets/market_type.py

@@ -0,0 +1,74 @@
+from enum import Enum
+from typing import TypeVar
+
+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
+from prediction_market_agent_tooling.markets.manifold.manifold import (
+    ManifoldAgentMarket,
+)
+from prediction_market_agent_tooling.markets.metaculus.metaculus import (
+    MetaculusAgentMarket,
+)
+from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
+from prediction_market_agent_tooling.markets.polymarket.polymarket import (
+    PolymarketAgentMarket,
+)
+from prediction_market_agent_tooling.markets.seer.seer import SeerAgentMarket
+
+T = TypeVar("T", bound=AgentMarket)
+
+
+class MarketType(str, Enum):
+    # Note: Always keep the omen market first, as it is the main market for us.
+    OMEN = "omen"
+    MANIFOLD = "manifold"
+    POLYMARKET = "polymarket"
+    METACULUS = "metaculus"
+    SEER = "seer"
+
+    @staticmethod
+    def from_market(market: AgentMarket) -> "MarketType":
+        return AGENT_MARKET_TO_MARKET_TYPE[type(market)]
+
+    @property
+    def market_class(self) -> type[AgentMarket]:
+        if self not in MARKET_TYPE_TO_AGENT_MARKET:
+            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_trading_market(self) -> bool:
+        return self in [
+            MarketType.OMEN,
+            MarketType.POLYMARKET,
+            MarketType.SEER,
+            MarketType.MANIFOLD,
+        ]
+
+    @property
+    def is_blockchain_market(self) -> bool:
+        return self in [MarketType.OMEN, MarketType.POLYMARKET, MarketType.SEER]
+
+
+MARKET_TYPE_TO_AGENT_MARKET: dict[MarketType, type[AgentMarket]] = {
+    MarketType.MANIFOLD: ManifoldAgentMarket,
+    MarketType.OMEN: OmenAgentMarket,
+    MarketType.POLYMARKET: PolymarketAgentMarket,
+    MarketType.METACULUS: MetaculusAgentMarket,
+    MarketType.SEER: SeerAgentMarket,
+}
+
+AGENT_MARKET_TO_MARKET_TYPE: dict[type[AgentMarket], MarketType] = {
+    v: k for k, v in MARKET_TYPE_TO_AGENT_MARKET.items()
+}
+
+JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET: dict[MarketType, type[JobAgentMarket]] = {
+    MarketType.OMEN: OmenJobAgentMarket,
+}

prediction_market_agent_tooling/markets/markets.py

@@ -1,78 +1,16 @@
 import typing as t
-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,
+    QuestionType,
     SortBy,
 )
-from prediction_market_agent_tooling.markets.manifold.api import (
-    get_authenticated_user,
-    get_manifold_bets,
-    get_manifold_market,
+from prediction_market_agent_tooling.markets.market_type import (
+    MARKET_TYPE_TO_AGENT_MARKET,
+    MarketType,
 )
-from prediction_market_agent_tooling.markets.manifold.manifold import (
-    ManifoldAgentMarket,
-)
-from prediction_market_agent_tooling.markets.metaculus.metaculus import (
-    MetaculusAgentMarket,
-)
-from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
-from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
-    OmenSubgraphHandler,
-)
-from prediction_market_agent_tooling.markets.polymarket.polymarket import (
-    PolymarketAgentMarket,
-)
-from prediction_market_agent_tooling.markets.seer.seer import SeerAgentMarket
-from prediction_market_agent_tooling.tools.utils import (
-    DatetimeUTC,
-    should_not_happen,
-    utcnow,
-)
-
-
-class MarketType(str, Enum):
-    # Note: Always keep the omen market first, as it is the main market for us.
-    OMEN = "omen"
-    MANIFOLD = "manifold"
-    POLYMARKET = "polymarket"
-    METACULUS = "metaculus"
-    SEER = "seer"
-
-    @property
-    def market_class(self) -> type[AgentMarket]:
-        if self not in MARKET_TYPE_TO_AGENT_MARKET:
-            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, MarketType.SEER]
-
-
-MARKET_TYPE_TO_AGENT_MARKET: dict[MarketType, type[AgentMarket]] = {
-    MarketType.MANIFOLD: ManifoldAgentMarket,
-    MarketType.OMEN: OmenAgentMarket,
-    MarketType.POLYMARKET: PolymarketAgentMarket,
-    MarketType.METACULUS: MetaculusAgentMarket,
-    MarketType.SEER: SeerAgentMarket,
-}
-
-
-JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET: dict[MarketType, type[JobAgentMarket]] = {
-    MarketType.OMEN: OmenJobAgentMarket,
-}
+from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
 
 def get_binary_markets(
@@ -82,6 +20,7 @@ def get_binary_markets(
     sort_by: SortBy = SortBy.NONE,
     excluded_questions: set[str] | None = None,
     created_after: DatetimeUTC | None = None,
+    question_type: QuestionType = QuestionType.BINARY,
 ) -> t.Sequence[AgentMarket]:
     agent_market_class = MARKET_TYPE_TO_AGENT_MARKET[market_type]
     markets = agent_market_class.get_markets(
@@ -90,37 +29,6 @@ def get_binary_markets(
         filter_by=filter_by,
         created_after=created_after,
         excluded_questions=excluded_questions,
+        question_type=question_type,
     )
     return markets
-
-
-def have_bet_on_market_since(
-    keys: APIKeys, market: AgentMarket, since: timedelta
-) -> bool:
-    start_time = utcnow() - since
-    recently_betted_questions = (
-        set(
-            get_manifold_market(b.contractId).question
-            for b in get_manifold_bets(
-                user_id=get_authenticated_user(
-                    keys.manifold_api_key.get_secret_value()
-                ).id,
-                start_time=start_time,
-                end_time=None,
-            )
-        )
-        if isinstance(market, ManifoldAgentMarket)
-        else (
-            set(
-                b.title
-                for b in OmenSubgraphHandler().get_bets(
-                    better_address=keys.bet_from_address,
-                    start_time=start_time,
-                    market_id=market.market_maker_contract_address_checksummed,
-                )
-            )
-            if isinstance(market, OmenAgentMarket)
-            else should_not_happen(f"Unknown market: {market}")
-        )
-    )
-    return market.question in recently_betted_questions

prediction_market_agent_tooling/markets/metaculus/data_models.py

@@ -14,13 +14,13 @@ class QuestionType(str, Enum):
 class AggregationItem(BaseModel):
     start_time: DatetimeUTC
     end_time: DatetimeUTC | None
-    forecast_values: list[float] | None
+    forecast_values: list[float] | None = None
     forecaster_count: int
     interval_lower_bounds: list[float] | None
     centers: list[float] | None
     interval_upper_bounds: list[float] | None
-    means: list[float] | None
-    histogram: list[list[float]] | None
+    means: list[float] | None = None
+    histogram: list[list[float]] | None = None
 
 
 class Aggregation(BaseModel):

prediction_market_agent_tooling/markets/metaculus/metaculus.py

@@ -5,12 +5,13 @@ 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,
+    ConditionalFilterType,
     FilterBy,
     MarketFees,
     ProcessedMarket,
+    QuestionType,
     SortBy,
 )
 from prediction_market_agent_tooling.markets.metaculus.api import (
@@ -43,13 +44,7 @@ class MetaculusAgentMarket(AgentMarket):
         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.")
+        # We don't check for outcomes match here because Metaculus has no filled outcomes.
         return probs
 
     @staticmethod
@@ -79,6 +74,8 @@ class MetaculusAgentMarket(AgentMarket):
         filter_by: FilterBy = FilterBy.OPEN,
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
+        question_type: QuestionType = QuestionType.ALL,
+        conditional_filter_type: ConditionalFilterType = ConditionalFilterType.ONLY_NOT_CONDITIONAL,
         tournament_id: int | None = None,
     ) -> t.Sequence["MetaculusAgentMarket"]:
         order_by: str | None

prediction_market_agent_tooling/markets/omen/cow_contracts.py

@@ -3,7 +3,7 @@ import os
 from web3 import Web3
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import ABI, HexBytes
+from prediction_market_agent_tooling.gtypes import ABI, ChecksumAddress, HexBytes
 from prediction_market_agent_tooling.tools.contract import (
     ContractOnGnosisChain,
     abi_field_validator,
@@ -19,6 +19,10 @@ class CowGPv2SettlementContract(ContractOnGnosisChain):
         )
     )
 
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0x9008D19f58AAbD9eD0D60971565AA8510560ab41"
+    )
+
     def setPreSignature(
         self,
         api_keys: APIKeys,